From f91cf2d1cf2547b94f88d1e7225e825b627f9bdd Mon Sep 17 00:00:00 2001 From: Tom St Denis Date: Sat, 23 Jul 2005 10:43:03 +0000 Subject: [PATCH] added tomsfastmath-0.04 --- TODO | 20 - changes.txt | 22 +- comba_mont_gen.c | 81 + comba_mult_gen.c | 14 + comba_mult_smallgen.c | 61 + comba_sqr_gen.c | 14 + comba_sqr_smallgen.c | 109 + delme.c | 24 - demo/rsa.c | 83 + demo/stest.c | 4 + demo/test.c | 43 +- doc/tfm.pdf | Bin 125198 -> 122170 bytes fp_2expt.c | 6 +- fp_add.c | 6 +- fp_add_d.c | 6 +- fp_addmod.c | 6 +- fp_cmp.c | 6 +- fp_cmp_d.c | 6 +- fp_cmp_mag.c | 6 +- fp_cnt_lsb.c | 6 +- fp_count_bits.c | 6 +- fp_div.c | 6 +- fp_div_2.c | 6 +- fp_div_2d.c | 6 +- fp_div_d.c | 6 +- fp_exptmod.c | 17 +- fp_gcd.c | 6 +- fp_ident.c | 16 +- fp_invmod.c | 6 +- fp_isprime.c | 6 +- fp_lcm.c | 6 +- fp_lshd.c | 6 +- fp_mod.c | 6 +- fp_mod_2d.c | 6 +- fp_mod_d.c | 6 +- fp_montgomery_calc_normalization.c | 6 +- fp_montgomery_reduce.c | 632 +-- fp_montgomery_setup.c | 6 +- fp_mul.c | 46 +- fp_mul_2.c | 6 +- fp_mul_2d.c | 6 +- fp_mul_comba.c | 2436 ++++++++++-- fp_mul_d.c | 6 +- fp_mulmod.c | 6 +- fp_prime_miller_rabin.c | 6 +- fp_prime_random_ex.c | 6 +- fp_radix_size.c | 6 +- fp_read_radix.c | 6 +- fp_read_signed_bin.c | 6 +- fp_read_unsigned_bin.c | 6 +- fp_reverse.c | 6 +- fp_rshd.c | 6 +- fp_s_rmap.c | 6 +- fp_set.c | 6 +- fp_signed_bin_size.c | 6 +- fp_sqr.c | 29 +- fp_sqr_comba.c | 2363 +++++++++-- fp_sqr_comba_generic.c | 14 + fp_sqrmod.c | 6 +- fp_sub.c | 6 +- fp_sub_d.c | 6 +- fp_submod.c | 6 +- fp_to_signed_bin.c | 6 +- fp_to_unsigned_bin.c | 6 +- fp_toradix.c | 6 +- fp_unsigned_bin_size.c | 6 +- makefile | 53 +- mess.sh | 4 + mtest/makefile | 2 +- mtest/mtest.c | 6 +- pre_gen/mpi.c | 5841 +++++++++++++++++++++++----- s_fp_add.c | 6 +- s_fp_sub.c | 6 +- tfm.aux | 56 + tfm.dvi | Bin 0 -> 49708 bytes tfm.h | 81 +- tfm.idx | 29 + tfm.ilg | 6 + tfm.ind | 33 + tfm.lof | 5 + tfm.log | 332 ++ tfm.tex | 48 +- tfm.toc | 33 + 83 files changed, 10946 insertions(+), 1899 deletions(-) delete mode 100644 TODO create mode 100644 comba_mont_gen.c create mode 100644 comba_mult_smallgen.c create mode 100644 comba_sqr_smallgen.c delete mode 100644 delme.c create mode 100644 demo/rsa.c create mode 100644 mess.sh create mode 100644 tfm.aux create mode 100644 tfm.dvi create mode 100644 tfm.idx create mode 100644 tfm.ilg create mode 100644 tfm.ind create mode 100644 tfm.lof create mode 100644 tfm.log create mode 100644 tfm.toc diff --git a/TODO b/TODO deleted file mode 100644 index c67a55b..0000000 --- a/TODO +++ /dev/null @@ -1,20 +0,0 @@ ---- -0. IMPORTANT... why are you doubling the "even" terms individually? STUPID! - - make it so you have four new macros that use an additional 3 carry variables - - SQRADDSC - store first mult [ simple store, no carry ] - - SQRADDAC - add subsequent mults [ 3n word add ] - - SQRADDDB - double the carry [ 3n word add ] - - SQRADDFC - forward the doubles into the main [ 3n word add, note, x86_32 may need "g" instead of "r" ] - - only use the four macro pattern for rows with >= 3 "doubles" - - otherwise use the existing SQRADD - - -1. Write more documentation ;-) -2. Ports to PPC and MIPS -3. Fix any lingering bugs, add additional requested functionality. -4. Unrolled copies of montgomery will speed it up a bit -5. - - -NOTE: The library is still fairly new. I've tested it quite a bit but that doesn't mean surprises -can't happen. Please test the results you get for correctness. diff --git a/changes.txt b/changes.txt index 1b5f216..5ad2fb7 100644 --- a/changes.txt +++ b/changes.txt @@ -1,7 +1,25 @@ +0.04 -- Fixed bugs in the SSE2 squaring code + -- Rewrote the multipliers to be optimized for small inputs + -- Nelson Bolyard of the NSS crew submitted [among other things] new faster Montgomery reduction + code. It brings the performance for small numbers on the AMD64 and all numbers on the P4 + to a new level. Thanks! + -- Added missing ARM support for fp_montgomery_reduce.c that the NSS folk left off, Officially + the ARM code is for v4 and above WITH the "M" multiplier support (e.g. umlal instruction) + -- Added PPC32 support, define TFM_PPC32 to enable it, I used the "PowerPC 6xx" instruction + databook for reference. Does not require altivec. Should be fairly portable to the other + 32-bit PPCs provided they have mullw and mulhwu instructions. + [Note: porting the macros to PPC64 should be trivial, anyone with a shell to lend... email me!] + -- Rewrote the config a bit in tfm.h so you can better choose which set of "oh my god that's huge" code to + enable for your task. "generic" functions are ALWAYS included which are smaller but will cover the + gaps in the coverage for ya. + -- The PPC32 code has been verified to function on a Darwin box running GCC 2.95.2 + [Thanks to the folk at PeerSec for lending me a shell to use] + -- Fixed a bug in fp_exptmod() where if the exponent was negative AND the destination the output + would have the sign set to FP_NEG. + March 1st, 2005 0.03 -- Optimized squaring - -- - + -- Applied new license header to all files (still PD) September 18th, 2004 0.02 -- Added TFM_LARGE to turn on/off 16x combas to save even more space. diff --git a/comba_mont_gen.c b/comba_mont_gen.c new file mode 100644 index 0000000..7b5e6fb --- /dev/null +++ b/comba_mont_gen.c @@ -0,0 +1,81 @@ +/* generate montgomery reductions for m->used = 1...16 */ + +#include + +int main(void) +{ + int N; + + for (N = 1; N <= 16; N++) { + +printf("void fp_montgomery_reduce_%d(fp_int *a, fp_int *m, fp_digit mp)\n", N); +printf( +"{\n" +" fp_digit c[3*FP_SIZE], *_c, *tmpm, mu;\n" +" int oldused, x, y;\n" +"\n" +" /* now zero the buff */\n" +" memset(c, 0, sizeof(c));\n" +"\n" +" /* copy the input */\n" +" oldused = a->used;\n" +" for (x = 0; x < oldused; x++) {\n" +" c[x] = a->dp[x];\n" +" }\n" +"\n" +" MONT_START;\n" +"\n" +" /* now let's get bizz-sy! */\n" +" for (x = 0; x < %d; x++) {\n" +" /* get Mu for this round */\n" +" LOOP_START;\n" +"\n" +" /* our friendly neighbourhood alias */\n" +" _c = c + x;\n" +" tmpm = m->dp;\n" +"\n" +" for (y = 0; y < %d; y++) {\n" +" INNERMUL;\n" +" ++_c;\n" +" }\n" +" /* send carry up man... */\n" +" _c = c + x;\n" +" PROPCARRY;\n" +" } \n" +"\n" +" /* fix the rest of the carries */\n" +" _c = c + %d;\n" +" for (x = %d; x < %d * 2 + 2; x++) {\n" +" PROPCARRY;\n" +" ++_c;\n" +" }\n" +"\n" +" /* now copy out */\n" +" _c = c + %d;\n" +" tmpm = a->dp;\n" +" for (x = 0; x < %d+1; x++) {\n" +" *tmpm++ = *_c++;\n" +" }\n" +"\n" +" for (; x < oldused; x++) {\n" +" *tmpm++ = 0;\n" +" }\n" +"\n" +" MONT_FINI;\n" +"\n" +" a->used = %d+1;\n" +" fp_clamp(a);\n" +"\n" +" /* if A >= m then A = A - m */\n" +" if (fp_cmp_mag (a, m) != FP_LT) {\n" +" s_fp_sub (a, m, a);\n" +" }\n" +"}\n", N,N,N,N,N,N,N,N); +} + +return 0; +} + + + + diff --git a/comba_mult_gen.c b/comba_mult_gen.c index b43471d..257d568 100644 --- a/comba_mult_gen.c +++ b/comba_mult_gen.c @@ -1,3 +1,13 @@ +/* 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@gmail.com + */ + /* program emits a NxN comba multiplier */ #include @@ -47,3 +57,7 @@ printf( return 0; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/comba_mult_smallgen.c b/comba_mult_smallgen.c new file mode 100644 index 0000000..1659bb4 --- /dev/null +++ b/comba_mult_smallgen.c @@ -0,0 +1,61 @@ +/* program emits a NxN comba multiplier for 1x1 to 16x16 */ +#include + +int main(int argc, char **argv) +{ + int N, x, y, z; + + /* print out preamble */ +printf( +"void fp_mul_comba_small(fp_int *A, fp_int *B, fp_int *C)\n" +"{\n" +" fp_digit c0, c1, c2, at[32];\n" +" switch (MAX(A->used, B->used)) { \n" +); + +for (N = 1; N <= 16; N++) { + +printf( +"\n" +" case %d:\n" +" memcpy(at, A->dp, %d * sizeof(fp_digit));\n" +" memcpy(at+%d, B->dp, %d * sizeof(fp_digit));\n" +" COMBA_START;\n" +"\n" +" COMBA_CLEAR;\n", N, N, N, N); + + /* now do the rows */ + for (x = 0; x < (N+N-1); x++) { +printf( +" /* %d */\n", x); +if (x > 0) { +printf( +" COMBA_FORWARD;\n"); +} + for (y = 0; y < N; y++) { + for (z = 0; z < N; z++) { + if ((y+z)==x) { + printf(" MULADD(at[%d], at[%d]); ", y, z+N); + } + } + } +printf( +"\n" +" COMBA_STORE(C->dp[%d]);\n", x); + } +printf( +" COMBA_STORE2(C->dp[%d]);\n" +" C->used = %d;\n" +" C->sign = A->sign ^ B->sign;\n" +" fp_clamp(C);\n" +" COMBA_FINI;\n" +" break;\n", N+N-1, N+N); +} +printf(" }\n}\n\n"); + + return 0; +} + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/comba_sqr_gen.c b/comba_sqr_gen.c index bae9051..2e97878 100644 --- a/comba_sqr_gen.c +++ b/comba_sqr_gen.c @@ -1,3 +1,13 @@ +/* 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@gmail.com + */ + /* Generates squaring comba code... it learns it knows our secrets! */ #include @@ -90,3 +100,7 @@ if (N >= 16) printf("#endif\n"); return 0; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/comba_sqr_smallgen.c b/comba_sqr_smallgen.c new file mode 100644 index 0000000..c6e58c9 --- /dev/null +++ b/comba_sqr_smallgen.c @@ -0,0 +1,109 @@ +/* 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@gmail.com + */ + +/* Generates squaring comba code... it learns it knows our secrets! */ +#include + +int main(int argc, char **argv) +{ + int x, y, z, N, f; + +printf( +"void fp_sqr_comba_small(fp_int *A, fp_int *B)\n" +"{\n" +" fp_digit *a, b[32], c0, c1, c2, sc0, sc1, sc2;\n" +); + +printf(" switch (A->used) { \n"); + +for (N = 1; N <= 16; N++) { +printf( +" case %d:\n" +" a = A->dp;\n" +" COMBA_START; \n" +"\n" +" /* clear carries */\n" +" CLEAR_CARRY;\n" +"\n" +" /* output 0 */\n" +" SQRADD(a[0],a[0]);\n" +" COMBA_STORE(b[0]);\n", N); + + for (x = 1; x < N+N-1; x++) { +printf( +"\n /* output %d */\n" +" CARRY_FORWARD;\n ", x); + + for (f = y = 0; y < N; y++) { + for (z = 0; z < N; z++) { + if (z != y && z + y == x && y <= z) { + ++f; + } + } + } + + if (f <= 2) { + for (y = 0; y < N; y++) { + for (z = 0; z < N; z++) { + if (y<=z && (y+z)==x) { + if (y == z) { + printf(" SQRADD(a[%d], a[%d]); ", y, y); + } else { + printf(" SQRADD2(a[%d], a[%d]); ", y, z); + } + } + } + } + } else { + // new method + /* do evens first */ + f = 0; + for (y = 0; y < N; y++) { + for (z = 0; z < N; z++) { + if (z != y && z + y == x && y <= z) { + if (f == 0) { + // first double + printf("SQRADDSC(a[%d], a[%d]); ", y, z); + f = 1; + } else { + printf("SQRADDAC(a[%d], a[%d]); ", y, z); + } + } + } + } + // forward the carry + printf("SQRADDDB; "); + if ((x&1) == 0) { + // add the square + printf("SQRADD(a[%d], a[%d]); ", x/2, x/2); + } + } +printf("\n COMBA_STORE(b[%d]);\n", x); + } +printf(" COMBA_STORE2(b[%d]);\n", N+N-1); + +printf( +" COMBA_FINI;\n" +"\n" +" B->used = %d;\n" +" B->sign = FP_ZPOS;\n" +" memcpy(B->dp, b, %d * sizeof(fp_digit));\n" +" fp_clamp(B);\n" +" break;\n\n", N+N, N+N); +} + +printf("}\n\n}\n"); + + return 0; +} + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/delme.c b/delme.c deleted file mode 100644 index 7fb0ad5..0000000 --- a/delme.c +++ /dev/null @@ -1,24 +0,0 @@ -#include "tfm.h" - -int main(void) -{ - fp_int a; - char buf[4096]; - - fp_init(&a); - fp_read_radix( &a, - "///////////93zgY8MZ2DCJ6Oek0t1pHAG9E28fdp7G22xwcEnER8b5A27cED0JT" - "xvKPiyqwGnimAmfjybyKDq/XDMrjKS95v8MrTc9UViRqJ4BffZVjQml/NBRq1hVj" - "xZXh+rg9dwMkdoGHV4iVvaaePb7iv5izmW1ykA5ZlmMOsaWs75NJccaMFwZz9CzV" - "WsLT8zoZhPOSOlDM88LIkvxLAGTmbfPjPmmrJagyc0JnT6m8oXWXV3AGNaOkDiux" - "uvvtB1WEXWER9uEYx0UYZxN5NV1lJ5B9tYlBzfLO5nWvbKbywfLgvHNI9XYO+WKG" - "5NAEMeggn2sjCnSD151wCwXL8QlV7BfaxFk515ZRxmgAwd5NNGOCVREN3uMcuUJ7" - "g/MkZDi9CzSUZ9JWIYLXdSxZqYOQqkvhyI/w1jcA26JOTW9pFiXgP58VAnWNUo0C" - "k+4NLtfXNMnt2OZ0kjb6uWZYJw1qvQinGzjR/E3z48vBWj4WgJhIol//////////", - 64 ); - - if( fp_isprime( &a ) ) printf("It's prime.\n"); - else printf( "Not prime.\n"); - - return 0; -} diff --git a/demo/rsa.c b/demo/rsa.c new file mode 100644 index 0000000..d62c174 --- /dev/null +++ b/demo/rsa.c @@ -0,0 +1,83 @@ +#include "tfm.h" +#include + +int main(void) +{ + fp_int d, e, n, c, m, e_m; + clock_t t1; + int x; + + /* read in the parameters */ + fp_read_radix(&n, "ce032e860a9809a5ec31e4b0fd4b546f8c40043e3d2ec3d8f49d8f2f3dd19e887094ee1af75caa1c2e6cd9ec78bf1dfd6280002ac8c30ecd72da2e4c59a28a9248048aaae2a8fa627f71bece979cebf9f8eee2bd594d4a4f2e791647573c7ec1fcbd320d3825be3fa8a17c97086fdae56f7086ce512b81cc2fe44161270ec5e9", 16); + fp_read_radix(&e, "10001", 16); + fp_read_radix(&m, "39f5a911250f45b99390e2df322b33c729099ab52b5879d06b00818cce57c649a66ed7eb6d8ae214d11caf9c81e83a7368cf0edb2b71dad791f13fecf546123b40377851e67835ade1d6be57f4de18a62db4cdb1880f4ab2e6a29acfd85ca22a13dc1f6fee2621ef0fc8689cd738e6f065c033ec7c148d8d348688af83d6f6bd", 16); + fp_read_radix(&c, "9ff70ea6968a04530e6b06bf01aa937209cc8450e76ac19477743de996ba3fb445923c947f8d0add8c57efa51d15485309918459da6c1e5a97f215193b797dce98db51bdb4639c2ecfa90ebb051e3a2daeffd27a7d6e62043703a7b15e0ada5170427b63099cd01ef52cd92d8723e5774bea32716aaa7f5adbae817fb12a5b50", 16); + + /* test it */ + fp_exptmod(&m, &e, &n, &e_m); + if (fp_cmp(&e_m, &c)) { + char buf[1024]; + printf("Encrypted text not equal\n"); + fp_toradix(&e_m, buf, 16); + printf("e_m == %s\n", buf); + return 0; + } + + printf("CLOCKS_PER_SEC = %llu\n", (unsigned long long)CLOCKS_PER_SEC); + t1 = clock(); + for (x = 0; x < 1000; x++) { + fp_exptmod(&m, &e, &n, &e_m); + } + t1 = clock() - t1; + printf("1000 RSA operations took %10.5g seconds\n", (double)t1 / (double)CLOCKS_PER_SEC); + printf("RSA encrypt/sec %10.5g\n", (double)CLOCKS_PER_SEC / ((double)t1 / 1000.0) ); + + /* read in the parameters */ + fp_read_radix(&n, "a7f30e2e04d31acc6936916af1e404a4007adfb9e97864de28d1c7ba3034633bee2cd9d5da3ea3cdcdc9a6f3daf5702ef750f4c3aadb0e27410ac04532176795995148cdb4691bd09a8a846e3e24e073ce2f89b34dfeb2ee89b646923ca60ee3f73c4d5397478380425e7260f75dfdc54826e160395b0889b1162cf115a9773f", 16); + fp_read_radix(&d, "16d166f3c9a404d810d3611e6e8ed43293fe1db75c8906eb4810785a4b82529929dade1db7f11ac0335d5a59773e3167b022479eedefa514a0399db5c900750a56323cf9f5b0f21e7d60a46d75f3fcaabf30a63cbe34048b741a57ac36a13914afda798709dea5771f8d456cf72ec5f3afc1d88d023de40311143a36e7028739", 16); + fp_read_radix(&c, "7d216641c32543f5b8428bdd0b11d819cfbdb16f1df285247f677aa4d44de62ab064f4a0d060ec99cb94aa398113a4317f2c550d0371140b0fd2c88886cac771812e72faad4b7adf495b9b850b142ccd7f45c0a27f164c8c7731731c0015f69d0241812e769d961054618aeb9e8e8989dba95714a2cf56c9e525c5e34b5812dd", 16); + fp_read_radix(&m, "5f323bf0b394b98ffd78727dc9883bb4f42287def6b60fa2a964b2510bc55d61357bf5a6883d2982b268810f8fef116d3ae68ebb41fd10d65a0af4bec0530eb369f37c14b55c3be60223b582372fb6589b648d5a0c7252d1ae2dae5809785d993e9e5d0c4d9b0bcba0cde0d6671734747fba5483c735e1dab7df7b10ec6f62d8", 16); + + /* test it */ + fp_exptmod(&c, &d, &n, &e_m); + if (fp_cmp(&e_m, &m)) { + char buf[1024]; + printf("Decrypted text not equal\n"); + fp_toradix(&e_m, buf, 16); + printf("e_m == %s\n", buf); + return 0; + } + + t1 = clock(); + for (x = 0; x < 100; x++) { + fp_exptmod(&c, &d, &n, &e_m); + } + t1 = clock() - t1; + printf("100 RSA operations took %10.5g seconds\n", (double)t1 / (double)CLOCKS_PER_SEC); + printf("RSA decrypt/sec %10.5g\n", (double)CLOCKS_PER_SEC / ((double)t1 / 100.0) ); + + + /* test half size */ + fp_rshd(&n, n.used >> 1); + fp_rshd(&d, d.used >> 1); + fp_rshd(&c, c.used >> 1); + printf("n.used == %4d bits\n", n.used * DIGIT_BIT); + + /* ensure n is odd */ + n.dp[0] |= 1; + t1 = clock(); + for (x = 0; x < 100; x++) { + fp_exptmod(&c, &d, &n, &e_m); + } + t1 = clock() - t1; + printf("100 RSA-half operations took %10.5g seconds\n", (double)t1 / (double)CLOCKS_PER_SEC); + printf("RSA decrypt/sec %10.5g (estimate of RSA-1024-CRT) \n", (double)CLOCKS_PER_SEC / ((double)t1 / 50.0) ); + + + + return 0; +} + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/demo/stest.c b/demo/stest.c index ede8f81..a790b63 100644 --- a/demo/stest.c +++ b/demo/stest.c @@ -142,3 +142,7 @@ int main(void) return 0; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/demo/test.c b/demo/test.c index 184cc85..fa87605 100644 --- a/demo/test.c +++ b/demo/test.c @@ -22,10 +22,18 @@ int myrng(unsigned char *dst, int len, void *dat) static ulong64 TIMFUNC (void) { #if defined __GNUC__ - #if defined(__i386__) || defined(__x86_64__) + #if defined(INTEL_CC) + ulong64 a; + asm ("rdtsc":"=A"(a)); + return a; + #elif defined(__i386__) || defined(__x86_64__) ulong64 a; __asm__ __volatile__ ("rdtsc\nmovl %%eax,%0\nmovl %%edx,4+%0\n"::"m"(a):"%eax","%edx"); return a; + #elif defined(TFM_PPC32) + unsigned long a; + __asm__ __volatile__ ("mftb %0":"=r"(a)); + return a; #else /* gcc-IA64 version */ unsigned long result; __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory"); @@ -135,9 +143,7 @@ int main(void) printf("Testing read_radix\n"); fp_read_radix(&a, "123456789012345678901234567890", 16); draw(&a); -goto testing; - -#if 1 +#if 0 /* test mont */ printf("Montgomery test #1\n"); fp_set(&a, 0x1234567ULL); @@ -196,8 +202,18 @@ goto testing; } printf("\n\n"); #endif - + +#ifdef TESTING +goto testing; +#endif + #if 1 + +t1 = TIMFUNC(); +sleep(1); +printf("Ticks per second: %llu\n", TIMFUNC() - t1); + +goto expttime; /* do some timings... */ printf("Addition:\n"); for (t = 2; t <= FP_SIZE/2; t += 2) { @@ -211,7 +227,7 @@ goto testing; a.used = t; b.used = t; t2 = -1; - for (ix = 0; ix < 2500; ++ix) { + for (ix = 0; ix < 25000; ++ix) { t1 = TIMFUNC(); fp_add(&a, &b, &c); fp_add(&a, &b, &c); fp_add(&a, &b, &c); fp_add(&a, &b, &c); @@ -222,6 +238,7 @@ goto testing; } printf("%5lu-bit: %9llu\n", t * DIGIT_BIT, t2); } +multtime: printf("Multiplication:\n"); for (t = 2; t <= FP_SIZE/2; t += 2) { fp_zero(&a); @@ -263,8 +280,8 @@ sqrtime: } printf("%5lu-bit: %9llu\n", t * DIGIT_BIT, t2); } -return; //#else +monttime: printf("Montgomery:\n"); for (t = 2; t <= (FP_SIZE/2)-2; t += 2) { fp_zero(&a); @@ -295,7 +312,7 @@ return; expttime: printf("Exptmod:\n"); - for (t = 512/DIGIT_BIT; t <= (FP_SIZE/2)-2; t += t) { + for (t = 512/DIGIT_BIT; t <= (FP_SIZE/2)-2; t += 256/DIGIT_BIT) { fp_zero(&a); fp_zero(&b); fp_zero(&c); @@ -309,7 +326,7 @@ expttime: c.used = t; t2 = -1; - for (ix = 0; ix < 256; ++ix) { + for (ix = 0; ix < 500; ++ix) { t1 = TIMFUNC(); fp_exptmod(&c, &b, &a, &d); fp_exptmod(&c, &b, &a, &d); @@ -320,10 +337,10 @@ expttime: } printf("%5lu-bit: %9llu\n", t * DIGIT_BIT, t2); } -return; - + return; #endif +return; testing: div2_n = mul2_n = inv_n = expt_n = lcm_n = gcd_n = add_n = @@ -567,3 +584,7 @@ draw(&a);draw(&b);draw(&c);draw(&d); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/doc/tfm.pdf b/doc/tfm.pdf index 13bd19add1f988fec504045ff3d86b4926897a52..0830505cb52516a02f86de3480605eb710f9bd6f 100644 GIT binary patch delta 85138 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�qY>v@UScPkx_Kr_si; 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 delta 87685 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

sYh5^tq6>T;8A=+pP!Twmdv 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 diff --git a/fp_2expt.c b/fp_2expt.c index b534a10..0e03861 100644 --- a/fp_2expt.c +++ b/fp_2expt.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -33,3 +33,7 @@ void fp_2expt(fp_int *a, int b) a->dp[z] = ((fp_digit)1) << (b % DIGIT_BIT); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_add.c b/fp_add.c index c3e05e3..5a85356 100644 --- a/fp_add.c +++ b/fp_add.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -37,3 +37,7 @@ void fp_add(fp_int *a, fp_int *b, fp_int *c) } } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_add_d.c b/fp_add_d.c index 879f974..5ffdd08 100644 --- a/fp_add_d.c +++ b/fp_add_d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -16,3 +16,7 @@ void fp_add_d(fp_int *a, fp_digit b, fp_int *c) fp_set(&tmp, b); fp_add(a,&tmp,c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_addmod.c b/fp_addmod.c index c14c7e3..97c2fa5 100644 --- a/fp_addmod.c +++ b/fp_addmod.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -17,3 +17,7 @@ int fp_addmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) fp_add(a, b, &tmp); return fp_mod(&tmp, c, d); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_cmp.c b/fp_cmp.c index 1d49b78..4aa9c96 100644 --- a/fp_cmp.c +++ b/fp_cmp.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -25,3 +25,7 @@ int fp_cmp(fp_int *a, fp_int *b) } } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_cmp_d.c b/fp_cmp_d.c index 389d30f..1d6f6fd 100644 --- a/fp_cmp_d.c +++ b/fp_cmp_d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -32,3 +32,7 @@ int fp_cmp_d(fp_int *a, fp_digit b) } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_cmp_mag.c b/fp_cmp_mag.c index 3c4b0ec..409c239 100644 --- a/fp_cmp_mag.c +++ b/fp_cmp_mag.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -29,3 +29,7 @@ int fp_cmp_mag(fp_int *a, fp_int *b) return FP_EQ; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_cnt_lsb.c b/fp_cnt_lsb.c index edf7a51..4e89227 100644 --- a/fp_cnt_lsb.c +++ b/fp_cnt_lsb.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -40,3 +40,7 @@ int fp_cnt_lsb(fp_int *a) return x; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_count_bits.c b/fp_count_bits.c index 0c9e565..baa6571 100644 --- a/fp_count_bits.c +++ b/fp_count_bits.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -30,3 +30,7 @@ int fp_count_bits (fp_int * a) } return r; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_div.c b/fp_div.c index 5a1dbee..171133a 100644 --- a/fp_div.c +++ b/fp_div.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -151,3 +151,7 @@ int fp_div(fp_int *a, fp_int *b, fp_int *c, fp_int *d) return FP_OKAY; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_div_2.c b/fp_div_2.c index 5652bf0..39c27c6 100644 --- a/fp_div_2.c +++ b/fp_div_2.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -47,3 +47,7 @@ void fp_div_2(fp_int * a, fp_int * b) b->sign = a->sign; fp_clamp (b); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_div_2d.c b/fp_div_2d.c index f46690c..b50e399 100644 --- a/fp_div_2d.c +++ b/fp_div_2d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -73,3 +73,7 @@ void fp_div_2d(fp_int *a, int b, fp_int *c, fp_int *d) fp_copy (&t, d); } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_div_d.c b/fp_div_d.c index 3d0db07..3dfb714 100644 --- a/fp_div_d.c +++ b/fp_div_d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -87,3 +87,7 @@ int fp_div_d(fp_int *a, fp_digit b, fp_int *c, fp_digit *d) return FP_OKAY; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_exptmod.c b/fp_exptmod.c index 8f1b382..a4a2e8d 100644 --- a/fp_exptmod.c +++ b/fp_exptmod.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -174,6 +174,13 @@ int fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y) fp_int tmp; int err; +#ifdef TFM_CHECK + /* prevent overflows */ + if (P->used > (FP_SIZE/2)) { + return FP_VAL; + } +#endif + /* is X negative? */ if (X->sign == FP_NEG) { /* yes, copy G and invmod it */ @@ -183,10 +190,16 @@ int fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y) } X->sign = FP_ZPOS; err = _fp_exptmod(&tmp, X, P, Y); - X->sign = FP_NEG; + if (X != Y) { + X->sign = FP_NEG; + } return err; } else { /* Positive exponent so just exptmod */ return _fp_exptmod(G, X, P, Y); } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_gcd.c b/fp_gcd.c index 08900b4..0cef8cb 100644 --- a/fp_gcd.c +++ b/fp_gcd.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -49,3 +49,7 @@ void fp_gcd(fp_int *a, fp_int *b, fp_int *c) } fp_copy(&u, c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_ident.c b/fp_ident.c index 105e3d2..99e8d14 100644 --- a/fp_ident.c +++ b/fp_ident.c @@ -1,3 +1,12 @@ +/* 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@gmail.com + */ #include "tfm.h" const char *fp_ident(void) @@ -39,9 +48,6 @@ const char *fp_ident(void) #ifdef FP_64BIT " FP_64BIT " #endif -#ifdef TFM_LARGE -" TFM_LARGE " -#endif #ifdef TFM_HUGE " TFM_HUGE " #endif @@ -64,3 +70,7 @@ int main(void) #endif + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_invmod.c b/fp_invmod.c index d6c184f..17ddb69 100644 --- a/fp_invmod.c +++ b/fp_invmod.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -96,3 +96,7 @@ top: c->sign = neg; return FP_OKAY; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_isprime.c b/fp_isprime.c index e9a6991..7642e93 100644 --- a/fp_isprime.c +++ b/fp_isprime.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -72,3 +72,7 @@ int fp_isprime(fp_int *a) } return FP_YES; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_lcm.c b/fp_lcm.c index 5182a58..a06fb44 100644 --- a/fp_lcm.c +++ b/fp_lcm.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -25,3 +25,7 @@ void fp_lcm(fp_int *a, fp_int *b, fp_int *c) fp_mul(a, &t2, c); } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_lshd.c b/fp_lshd.c index e569453..db983f5 100644 --- a/fp_lshd.c +++ b/fp_lshd.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -32,3 +32,7 @@ void fp_lshd(fp_int *a, int x) /* clamp digits */ fp_clamp(a); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mod.c b/fp_mod.c index 8fb027b..61cbb24 100644 --- a/fp_mod.c +++ b/fp_mod.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -28,3 +28,7 @@ int fp_mod(fp_int *a, fp_int *b, fp_int *c) } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mod_2d.c b/fp_mod_2d.c index dc2103c..f684784 100644 --- a/fp_mod_2d.c +++ b/fp_mod_2d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -36,3 +36,7 @@ void fp_mod_2d(fp_int *a, int b, fp_int *c) c->dp[b / DIGIT_BIT] &= ~((fp_digit)0) >> (DIGIT_BIT - b); fp_clamp (c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mod_d.c b/fp_mod_d.c index 7ac1ac6..8a56188 100644 --- a/fp_mod_d.c +++ b/fp_mod_d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -14,3 +14,7 @@ int fp_mod_d(fp_int *a, fp_digit b, fp_digit *c) { return fp_div_d(a, b, NULL, c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_montgomery_calc_normalization.c b/fp_montgomery_calc_normalization.c index f6791af..1ac28b7 100644 --- a/fp_montgomery_calc_normalization.c +++ b/fp_montgomery_calc_normalization.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -36,3 +36,7 @@ void fp_montgomery_calc_normalization(fp_int *a, fp_int *b) } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_montgomery_reduce.c b/fp_montgomery_reduce.c index 778a433..185c9f6 100644 --- a/fp_montgomery_reduce.c +++ b/fp_montgomery_reduce.c @@ -1,252 +1,380 @@ -/* 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 - -#if defined(TFM_X86) - -/* x86-32 code */ - -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -#define INNERMUL \ -asm( \ -"movl %7,%%eax \n\t" \ -"mull %6 \n\t" \ -"addl %%eax,%0 \n\t" \ -"adcl %%edx,%1 \n\t" \ -"adcl $0,%2 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(mu), "g"(*tmpm++) \ - : "%eax", "%edx", "%cc"); - -#define PROPCARRY \ -asm( \ -"movl %1,%%eax \n\t" \ -"addl %%eax,%6 \n\t" \ -"movl %2,%%eax \n\t" \ -"adcl %%eax,%7 \n\t" \ -"adcl $0,%8 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "m"(_c[OFF0+1]), "m"(_c[OFF1+1]), "m"(_c[OFF2+1]) \ -: "%eax", "%cc"); - -#elif defined(TFM_X86_64) -/* x86-64 code */ - -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -#define INNERMUL \ -asm( \ -"movq %7,%%rax \n\t" \ -"mulq %6 \n\t" \ -"addq %%rax,%0 \n\t" \ -"adcq %%rdx,%1 \n\t" \ -"adcq $0,%2 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(mu), "g"(*tmpm++) \ - : "%rax", "%rdx", "%cc"); - -#define PROPCARRY \ -asm( \ -"movq %1,%%rax \n\t" \ -"movq %2,%%rbx \n\t" \ -"addq %%rax,%6 \n\t" \ -"adcq %%rbx,%7 \n\t" \ -"adcq $0,%8 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "m"(_c[OFF0+1]), "m"(_c[OFF1+1]), "m"(_c[OFF2+1]) \ -: "%rax", "%rbx", "%cc"); - -#elif defined(TFM_SSE2) - -/* SSE2 code */ - -#define MONT_START \ -asm("movd %0,%%mm2"::"g"(mp)); - -#define MONT_FINI \ -asm("emms"); - -#define LOOP_START \ -asm(\ -"movd %0,%%mm1 \n\t" \ -"pmuludq %%mm2,%%mm1 \n\t" \ -:: "g"(c[x])); - -#define INNERMUL \ -asm( \ -"movd %6,%%mm0 \n\t" \ -"pmuludq %%mm1,%%mm0 \n\t" \ -"movd %%mm0,%%eax \n\t" \ -"psrlq $32, %%mm0 \n\t" \ -"addl %%eax,%0 \n\t" \ -"movd %%mm0,%%eax \n\t" \ -"adcl %%eax,%1 \n\t" \ -"adcl $0,%2 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(*tmpm++) \ - : "%eax", "%cc"); - -#define PROPCARRY \ -asm( \ -"movl %1,%%eax \n\t" \ -"addl %%eax,%6 \n\t" \ -"movl %2,%%eax \n\t" \ -"adcl %%eax,%7 \n\t" \ -"adcl $0,%8 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(_c[OFF0+1]), "g"(_c[OFF1+1]), "g"(_c[OFF2+1]) \ -: "%eax", "%cc"); - -#elif defined(TFM_ARM) - -/* ISO C code */ -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -/* NOTE: later write it using two regs instead of three for _c + ... */ -#define INNERMUL \ -asm( \ -"UMULL r0,r1,%0,%1 \n\t" \ -"LDR r2,[%2] \n\t" \ -"ADDS r2,r2,r0 \n\t" \ -"STR r2,[%2] \n\t" \ -"LDR r2,[%3] \n\t" \ -"ADCS r2,r2,r1 \n\t" \ -"STR r2,[%3] \n\t" \ -"LDR r2,[%4] \n\t" \ -"ADC r2,r2,#0 \n\t" \ -"STR r2,[%4] \n\t" \ -::"r"(mu),"r"(*tmpm++),"r"(_c + OFF0),"r"(_c + OFF1),"r"(_c + OFF2):"r0", "r1", "r2", "%cc"); - -#define PROPCARRY \ -asm( \ -"LDR r0,[%1] \n\t" \ -"LDR r1,[%0,#4] \n\t" \ -"ADDS r0,r0,r1 \n\t" \ -"STR r0,[%0,#4] \n\t" \ -"LDR r0,[%2] \n\t" \ -"LDR r1,[%1,#4] \n\t" \ -"ADCS r0,r0,r1 \n\t" \ -"STR r0,[%1,#4] \n\t" \ -"LDR r0,[%2,#4] \n\t" \ -"ADC r0,r0,#0 \n\t" \ -"STR r0,[%2,#4] \n\t" \ -::"r"(_c + OFF0),"r"(_c + OFF1),"r"(_c + OFF2):"r0", "r1", "%cc"); - -#else - -/* ISO C code */ -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -#define INNERMUL \ - do { fp_word t; \ - t = (fp_word)_c[OFF0] + ((fp_word)mu) * ((fp_word)*tmpm++); _c[OFF0] = t; \ - t = (fp_word)_c[OFF1] + (t >> DIGIT_BIT); _c[OFF1] = t; \ - _c[OFF2] += (t >> DIGIT_BIT); \ - } while (0); - -#define PROPCARRY \ - do { fp_word t; \ - t = (fp_word)_c[OFF0+1] + (fp_word)_c[OFF1]; _c[OFF0+1] = t; \ - t = (fp_word)_c[OFF1+1] + (t >> DIGIT_BIT) + (fp_word)_c[OFF2]; _c[OFF1+1] = t; \ - _c[OFF2+1] += (t >> DIGIT_BIT); \ - } while (0); - -#endif - - -#define OFF0 (0) -#define OFF1 (FP_SIZE) -#define OFF2 (FP_SIZE+FP_SIZE) - -/* computes x/R == x (mod N) via Montgomery Reduction */ -void fp_montgomery_reduce(fp_int *a, fp_int *m, fp_digit mp) -{ - fp_digit c[3*FP_SIZE], *_c, *tmpm, mu; - int oldused, x, y, pa; - - /* now zero the buff */ - pa = m->used; - memset(c, 0, sizeof(c)); - - /* copy the input */ - oldused = a->used; - for (x = 0; x < oldused; x++) { - c[x] = a->dp[x]; - } - - MONT_START; - - /* now let's get bizz-sy! */ - for (x = 0; x < pa; x++) { - /* get Mu for this round */ - LOOP_START; - - /* our friendly neighbourhood alias */ - _c = c + x; - tmpm = m->dp; - - for (y = 0; y < pa; y++) { - INNERMUL; - ++_c; - } - /* send carry up man... */ - _c = c + x; - PROPCARRY; - } - - /* fix the rest of the carries */ - _c = c + pa; - for (x = pa; x < pa * 2 + 2; x++) { - PROPCARRY; - ++_c; - } - - /* now copy out */ - _c = c + pa; - tmpm = a->dp; - for (x = 0; x < pa+1; x++) { - *tmpm++ = *_c++; - } - - for (; x < oldused; x++) { - *tmpm++ = 0; - } - - MONT_FINI; - - a->used = pa+1; - fp_clamp(a); - - /* if A >= m then A = A - m */ - if (fp_cmp_mag (a, m) != FP_LT) { - s_fp_sub (a, m, a); - } -} +/* 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@gmail.com + */ +#include + +/******************************************************************/ +#if defined(TFM_X86) +/* x86-32 code */ + +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + "movl %5,%%eax \n\t" \ + "mull %4 \n\t" \ + "addl %1,%%eax \n\t" \ + "adcl $0,%%edx \n\t" \ + "addl %%eax,%0 \n\t" \ + "adcl $0,%%edx \n\t" \ + "movl %%edx,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy), "g"(mu), "g"(*tmpm++) \ +: "%eax", "%edx", "%cc") + +#define PROPCARRY \ +asm( \ + "addl %1,%0 \n\t" \ + "setb %%al \n\t" \ + "movzbl %%al,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy) \ +: "%eax", "%cc") + +/******************************************************************/ +#elif defined(TFM_X86_64) +/* x86-64 code */ + +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + "movq %5,%%rax \n\t" \ + "mulq %4 \n\t" \ + "addq %1,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "addq %%rax,%0 \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rdx,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy), "r"(mu), "r"(*tmpm++) \ +: "%rax", "%rdx", "%cc") + +#define INNERMUL8 \ + asm( \ + "movq 0(%5),%%rax \n\t" \ + "movq 0(%2),%%r10 \n\t" \ + "movq 0x8(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x8(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x10(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x10(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x8(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x18(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x18(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x10(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x20(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x20(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x18(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x28(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x28(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x20(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x30(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x30(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x28(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x38(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x38(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x30(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x38(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ +:"=r"(_c), "=r"(cy) \ +: "0"(_c), "1"(cy), "g"(mu), "r"(tmpm)\ +: "%rax", "%rdx", "%r10", "%r11", "%cc") + + +#define PROPCARRY \ +asm( \ + "addq %1,%0 \n\t" \ + "setb %%al \n\t" \ + "movzbq %%al,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy) \ +: "%rax", "%cc") + +/******************************************************************/ +#elif defined(TFM_SSE2) +/* SSE2 code (assumes 32-bit fp_digits) */ +/* XMM register assignments: + * xmm0 *tmpm++, then Mu * (*tmpm++) + * xmm1 c[x], then Mu + * xmm2 mp + * xmm3 cy + * xmm4 _c[LO] + */ + +#define MONT_START \ + asm("movd %0,%%mm2"::"g"(mp)) + +#define MONT_FINI \ + asm("emms") + +#define LOOP_START \ +asm( \ +"movd %0,%%mm1 \n\t" \ +"pxor %%mm3,%%mm3 \n\t" \ +"pmuludq %%mm2,%%mm1 \n\t" \ +:: "g"(c[x])) + +/* pmuludq on mmx registers does a 32x32->64 multiply. */ +#define INNERMUL \ +asm( \ + "movd %1,%%mm4 \n\t" \ + "movd %2,%%mm0 \n\t" \ + "paddq %%mm4,%%mm3 \n\t" \ + "pmuludq %%mm1,%%mm0 \n\t" \ + "paddq %%mm0,%%mm3 \n\t" \ + "movd %%mm3,%0 \n\t" \ + "psrlq $32, %%mm3 \n\t" \ +:"=g"(_c[LO]) : "0"(_c[LO]), "g"(*tmpm++) ); + +#define LOOP_END \ +asm( "movd %%mm3,%0 \n" :"=r"(cy)) + +#define PROPCARRY \ +asm( \ + "addl %1,%0 \n\t" \ + "setb %%al \n\t" \ + "movzbl %%al,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy) \ +: "%eax", "%cc") + +/******************************************************************/ +#elif defined(TFM_ARM) + /* ARMv4 code */ + +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + " LDR r0,%1 \n\t" \ + " ADDS r0,r0,%0 \n\t" \ + " MOVCS %0,#1 \n\t" \ + " MOVCC %0,#0 \n\t" \ + " UMLAL r0,%0,%3,%4 \n\t" \ + " STR r0,%1 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"r"(mu),"r"(*tmpm++),"1"(_c[0]):"r0","%cc"); + +#define PROPCARRY \ +asm( \ + " LDR r0,%1 \n\t" \ + " ADDS r0,r0,%0 \n\t" \ + " STR r0,%1 \n\t" \ + " MOVCS %0,#1 \n\t" \ + " MOVCC %0,#0 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"1"(_c[0]):"r0","%cc"); + +#elif defined(TFM_PPC32) + +/* PPC32 */ +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + " mullw r16,%3,%4 \n\t" \ + " mulhwu r17,%3,%4 \n\t" \ + " addc r16,r16,%0 \n\t" \ + " addze r17,r17 \n\t" \ + " lwz r18,%1 \n\t" \ + " addc r16,r16,r18 \n\t" \ + " addze %0,r17 \n\t" \ + " stw r16,%1 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"r"(mu),"r"(*tmpm++),"1"(_c[0]):"r16", "r17", "r18","%cc"); + +#define PROPCARRY \ +asm( \ + " lwz r16,%1 \n\t" \ + " addc r16,r16,%0 \n\t" \ + " stw r16,%1 \n\t" \ + " xor %0,%0,%0 \n\t" \ + " addze %0,%0 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"1"(_c[0]):"r16","%cc"); + +/******************************************************************/ +#else + +/* ISO C code */ +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ + do { fp_word t; \ + _c[0] = t = ((fp_word)_c[0] + (fp_word)cy) + \ + (((fp_word)mu) * ((fp_word)*tmpm++)); \ + cy = (t >> DIGIT_BIT); \ + } while (0) + +#define PROPCARRY \ + do { fp_digit t = _c[0] += cy; cy = (t < cy); } while (0) + +#endif +/******************************************************************/ + + +#define LO 0 +#define HI 1 +#define CY 2 + +/* computes x/R == x (mod N) via Montgomery Reduction */ +void fp_montgomery_reduce(fp_int *a, fp_int *m, fp_digit mp) +{ + fp_digit c[FP_SIZE], *_c, *tmpm, mu; + int oldused, x, y, pa; + +#if defined(USE_MEMSET) + /* now zero the buff */ + memset(c, 0, sizeof c); +#endif + pa = m->used; + + /* copy the input */ + oldused = a->used; + for (x = 0; x < oldused; x++) { + c[x] = a->dp[x]; + } +#if !defined(USE_MEMSET) + for (; x < 2*pa+3; x++) { + c[x] = 0; + } +#endif + MONT_START; + + for (x = 0; x < pa; x++) { + fp_digit cy = 0; + /* get Mu for this round */ + LOOP_START; + _c = c + x; + tmpm = m->dp; + y = 0; + #if defined(TFM_X86_64) + for (; y < (pa & ~7); y += 8) { + INNERMUL8; + _c += 8; + tmpm += 8; + } + #endif + + for (; y < pa; y++) { + INNERMUL; + ++_c; + } + LOOP_END; + while (cy) { + PROPCARRY; // cy = cy > (*_c += cy); + ++_c; + } + } + + /* now copy out */ + _c = c + pa; + tmpm = a->dp; + for (x = 0; x < pa+1; x++) { + *tmpm++ = *_c++; + } + + for (; x < oldused; x++) { + *tmpm++ = 0; + } + + MONT_FINI; + + a->used = pa+1; + fp_clamp(a); + + /* if A >= m then A = A - m */ + if (fp_cmp_mag (a, m) != FP_LT) { + s_fp_sub (a, m, a); + } +} + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + diff --git a/fp_montgomery_setup.c b/fp_montgomery_setup.c index 0d22b6c..8bd9666 100644 --- a/fp_montgomery_setup.c +++ b/fp_montgomery_setup.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -42,3 +42,7 @@ int fp_montgomery_setup(fp_int *a, fp_digit *rho) return FP_OKAY; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mul.c b/fp_mul.c index cd0f2b1..71c5f47 100644 --- a/fp_mul.c +++ b/fp_mul.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -24,19 +24,26 @@ void fp_mul(fp_int *A, fp_int *B, fp_int *C) inputs are not close to the next power of two. That is, for example, if say y=17 then we would do (32-17)^2 = 225 unneeded multiplications */ - if (y <= 4) { - fp_mul_comba4(A,B,C); - } else if (y <= 8) { - fp_mul_comba8(A,B,C); -#if defined(TFM_LARGE) - } else if (y <= 16 && y >= 10) { - fp_mul_comba16(A,B,C); + +#ifdef TFM_SMALL_SET + if (y <= 16) { + fp_mul_comba_small(A,B,C); +#elif defined(TFM_HUGE) + if (0) { 1; #endif #if defined(TFM_HUGE) - } else if (y <= 32 && y >= 24) { + } else if (y <= 32) { fp_mul_comba32(A,B,C); + } else if (y <= 48) { + fp_mul_comba48(A,B,C); + } else if (y <= 64) { + fp_mul_comba64(A,B,C); #endif +#if !defined(TFM_HUGE) && !defined(TFM_SMALL_SET) + { +#else } else { +#endif fp_mul_comba(A,B,C); } } else { @@ -44,7 +51,7 @@ void fp_mul(fp_int *A, fp_int *B, fp_int *C) if A = ab and B = cd for ||a|| = r we need to solve - ac*r^2 + (-(a-b)(c-d) + ac + bd)*r + bd + ac*r^2 + ((a+b)(c+d) - (ac + bd))*r + bd So we solve for the three products then we form the final result with careful shifting and addition. @@ -72,7 +79,7 @@ Obvious points of optimization } else { t1.used = 0; } - t1.sign = A->sign; + t1.sign = 0; // fp_copy(B, &t2); fp_rshd(&t2, r); for (s = 0; s < B->used - r; s++) { @@ -86,7 +93,7 @@ Obvious points of optimization } else { t2.used = 0; } - t2.sign = B->sign; + t2.sign = 0; fp_copy(&t1, &amb); fp_copy(&t2, &cmd); fp_zero(&ac); @@ -100,7 +107,7 @@ Obvious points of optimization t2.dp[s] = B->dp[s]; } for (; s < FP_SIZE; s++) { - t1.dp[s] = 0; + t1.dp[s] = 0; t2.dp[s] = 0; } t1.used = r; @@ -108,18 +115,17 @@ Obvious points of optimization fp_clamp(&t1); fp_clamp(&t2); - fp_sub(&amb, &t1, &amb); fp_sub(&cmd, &t2, &cmd); + s_fp_add(&amb, &t1, &amb); s_fp_add(&cmd, &t2, &cmd); fp_zero(&bd); fp_mul(&t1, &t2, &bd); - /* now get the (a-b)(c-d) term */ + /* now get the (a+b)(c+d) term */ fp_zero(&comp); fp_mul(&amb, &cmd, &comp); /* now solve the system, do the middle term first */ - comp.sign ^= 1; - fp_add(&comp, &ac, &comp); - fp_add(&comp, &bd, &comp); + s_fp_sub(&comp, &ac, &comp); + s_fp_sub(&comp, &bd, &comp); fp_lshd(&comp, r); /* leading term */ @@ -134,3 +140,7 @@ Obvious points of optimization } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mul_2.c b/fp_mul_2.c index 951f4fd..daab849 100644 --- a/fp_mul_2.c +++ b/fp_mul_2.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -61,3 +61,7 @@ void fp_mul_2(fp_int * a, fp_int * b) b->sign = a->sign; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mul_2d.c b/fp_mul_2d.c index 3dc2b98..21d9a7a 100644 --- a/fp_mul_2d.c +++ b/fp_mul_2d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -41,3 +41,7 @@ void fp_mul_2d(fp_int *a, int b, fp_int *c) fp_clamp(c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mul_comba.c b/fp_mul_comba.c index ddd0cb3..472b2d3 100644 --- a/fp_mul_comba.c +++ b/fp_mul_comba.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ /* About this file... @@ -14,6 +14,11 @@ #include +#if defined(TFM_PRESCOTT) && defined(TFM_SSE2) + #undef TFM_SSE2 + #define TFM_X86 +#endif + /* these are the combas. Worship them. */ #if defined(TFM_X86) /* Generic x86 optimized code */ @@ -149,9 +154,38 @@ asm( \ " UMULL r0,r1,%6,%7 \n\t" \ " ADDS %0,%0,r0 \n\t" \ " ADCS %1,%1,r1 \n\t" \ -" ADC %2, %2, #0 \n\t" \ +" ADC %2,%2,#0 \n\t" \ :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j) : "r0", "r1", "%cc"); +#elif defined(TFM_PPC32) +/* For 32-bit PPC */ + +#define COMBA_START + +#define COMBA_CLEAR \ + c0 = c1 = c2 = 0; + +#define COMBA_FORWARD \ + do { c0 = c1; c1 = c2; c2 = 0; } while (0); + +#define COMBA_STORE(x) \ + x = c0; + +#define COMBA_STORE2(x) \ + x = c1; + +#define COMBA_FINI + +/* untested: will mulhwu change the flags? Docs say no */ +#define MULADD(i, j) \ +asm( \ + " mullw r16,%6,%7 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " mulhwu r16,%6,%7 \n\t" \ + " adde %1,%1,r16 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r16"); + #else /* ISO C code */ @@ -237,267 +271,1231 @@ void fp_mul_comba(fp_int *A, fp_int *B, fp_int *C) fp_copy(dst, C); } -void fp_mul_comba4(fp_int *A, fp_int *B, fp_int *C) -{ - fp_digit c0, c1, c2, at[8]; - - memcpy(at, A->dp, 4 * sizeof(fp_digit)); - memcpy(at+4, B->dp, 4 * sizeof(fp_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; - fp_clamp(C); - COMBA_FINI; -} - - -void fp_mul_comba8(fp_int *A, fp_int *B, fp_int *C) -{ - fp_digit c0, c1, c2, at[16]; - - memcpy(at, A->dp, 8 * sizeof(fp_digit)); - memcpy(at+8, B->dp, 8 * sizeof(fp_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; - fp_clamp(C); - COMBA_FINI; -} - -#if defined(TFM_LARGE) - -void fp_mul_comba16(fp_int *A, fp_int *B, fp_int *C) +#if defined(TFM_SMALL_SET) +void fp_mul_comba_small(fp_int *A, fp_int *B, fp_int *C) { fp_digit c0, c1, c2, at[32]; + switch (MAX(A->used, B->used)) { - memcpy(at, A->dp, 16 * sizeof(fp_digit)); - memcpy(at+16, B->dp, 16 * sizeof(fp_digit)); - COMBA_START; + case 1: + memcpy(at, A->dp, 1 * sizeof(fp_digit)); + memcpy(at+1, B->dp, 1 * sizeof(fp_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; - fp_clamp(C); - COMBA_FINI; + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[1]); + COMBA_STORE(C->dp[0]); + COMBA_STORE2(C->dp[1]); + C->used = 2; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 2: + memcpy(at, A->dp, 2 * sizeof(fp_digit)); + memcpy(at+2, B->dp, 2 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[2]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[3]); MULADD(at[1], at[2]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[1], at[3]); + COMBA_STORE(C->dp[2]); + COMBA_STORE2(C->dp[3]); + C->used = 4; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 3: + memcpy(at, A->dp, 3 * sizeof(fp_digit)); + memcpy(at+3, B->dp, 3 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[3]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[4]); MULADD(at[1], at[3]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[5]); MULADD(at[1], at[4]); MULADD(at[2], at[3]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[1], at[5]); MULADD(at[2], at[4]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[2], at[5]); + COMBA_STORE(C->dp[4]); + COMBA_STORE2(C->dp[5]); + C->used = 6; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 4: + memcpy(at, A->dp, 4 * sizeof(fp_digit)); + memcpy(at+4, B->dp, 4 * sizeof(fp_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; + fp_clamp(C); + COMBA_FINI; + break; + + case 5: + memcpy(at, A->dp, 5 * sizeof(fp_digit)); + memcpy(at+5, B->dp, 5 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[5]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[6]); MULADD(at[1], at[5]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[7]); MULADD(at[1], at[6]); MULADD(at[2], at[5]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[8]); MULADD(at[1], at[7]); MULADD(at[2], at[6]); MULADD(at[3], at[5]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[9]); MULADD(at[1], at[8]); MULADD(at[2], at[7]); MULADD(at[3], at[6]); MULADD(at[4], at[5]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[1], at[9]); MULADD(at[2], at[8]); MULADD(at[3], at[7]); MULADD(at[4], at[6]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[2], at[9]); MULADD(at[3], at[8]); MULADD(at[4], at[7]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[3], at[9]); MULADD(at[4], at[8]); + COMBA_STORE(C->dp[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[4], at[9]); + COMBA_STORE(C->dp[8]); + COMBA_STORE2(C->dp[9]); + C->used = 10; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 6: + memcpy(at, A->dp, 6 * sizeof(fp_digit)); + memcpy(at+6, B->dp, 6 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[6]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[7]); MULADD(at[1], at[6]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[8]); MULADD(at[1], at[7]); MULADD(at[2], at[6]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[9]); MULADD(at[1], at[8]); MULADD(at[2], at[7]); MULADD(at[3], at[6]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[10]); MULADD(at[1], at[9]); MULADD(at[2], at[8]); MULADD(at[3], at[7]); MULADD(at[4], at[6]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); MULADD(at[3], at[8]); MULADD(at[4], at[7]); MULADD(at[5], at[6]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[1], at[11]); MULADD(at[2], at[10]); MULADD(at[3], at[9]); MULADD(at[4], at[8]); MULADD(at[5], at[7]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[2], at[11]); MULADD(at[3], at[10]); MULADD(at[4], at[9]); MULADD(at[5], at[8]); + COMBA_STORE(C->dp[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[3], at[11]); MULADD(at[4], at[10]); MULADD(at[5], at[9]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[4], at[11]); MULADD(at[5], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[5], at[11]); + COMBA_STORE(C->dp[10]); + COMBA_STORE2(C->dp[11]); + C->used = 12; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 7: + memcpy(at, A->dp, 7 * sizeof(fp_digit)); + memcpy(at+7, B->dp, 7 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[7]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[8]); MULADD(at[1], at[7]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[9]); MULADD(at[1], at[8]); MULADD(at[2], at[7]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[10]); MULADD(at[1], at[9]); MULADD(at[2], at[8]); MULADD(at[3], at[7]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); MULADD(at[3], at[8]); MULADD(at[4], at[7]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); MULADD(at[5], at[7]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); MULADD(at[6], at[7]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + 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[7]); + /* 8 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[3], at[13]); MULADD(at[4], at[12]); MULADD(at[5], at[11]); MULADD(at[6], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[4], at[13]); MULADD(at[5], at[12]); MULADD(at[6], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[5], at[13]); MULADD(at[6], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[6], at[13]); + COMBA_STORE(C->dp[12]); + COMBA_STORE2(C->dp[13]); + C->used = 14; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 8: + memcpy(at, A->dp, 8 * sizeof(fp_digit)); + memcpy(at+8, B->dp, 8 * sizeof(fp_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; + fp_clamp(C); + COMBA_FINI; + break; + + case 9: + memcpy(at, A->dp, 9 * sizeof(fp_digit)); + memcpy(at+9, B->dp, 9 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[9]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[10]); MULADD(at[1], at[9]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[12]); MULADD(at[1], at[11]); MULADD(at[2], at[10]); MULADD(at[3], at[9]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); 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[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); 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]); MULADD(at[8], at[9]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[1], at[17]); MULADD(at[2], at[16]); 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]); MULADD(at[8], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); MULADD(at[8], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[3], at[17]); MULADD(at[4], at[16]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[4], at[17]); MULADD(at[5], at[16]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + MULADD(at[5], at[17]); MULADD(at[6], at[16]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + MULADD(at[6], at[17]); MULADD(at[7], at[16]); MULADD(at[8], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + MULADD(at[7], at[17]); MULADD(at[8], at[16]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[8], at[17]); + COMBA_STORE(C->dp[16]); + COMBA_STORE2(C->dp[17]); + C->used = 18; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 10: + memcpy(at, A->dp, 10 * sizeof(fp_digit)); + memcpy(at+10, B->dp, 10 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[10]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[12]); MULADD(at[1], at[11]); MULADD(at[2], at[10]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[13]); MULADD(at[1], at[12]); MULADD(at[2], at[11]); MULADD(at[3], at[10]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); 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[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); 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]); MULADD(at[8], at[10]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); MULADD(at[8], at[11]); MULADD(at[9], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[1], at[19]); MULADD(at[2], at[18]); MULADD(at[3], at[17]); MULADD(at[4], at[16]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); MULADD(at[9], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[2], at[19]); MULADD(at[3], at[18]); MULADD(at[4], at[17]); MULADD(at[5], at[16]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); MULADD(at[9], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[3], at[19]); MULADD(at[4], at[18]); MULADD(at[5], at[17]); MULADD(at[6], at[16]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + MULADD(at[4], at[19]); MULADD(at[5], at[18]); MULADD(at[6], at[17]); MULADD(at[7], at[16]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + MULADD(at[5], at[19]); MULADD(at[6], at[18]); MULADD(at[7], at[17]); MULADD(at[8], at[16]); MULADD(at[9], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + MULADD(at[6], at[19]); MULADD(at[7], at[18]); MULADD(at[8], at[17]); MULADD(at[9], at[16]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[7], at[19]); MULADD(at[8], at[18]); MULADD(at[9], at[17]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[8], at[19]); MULADD(at[9], at[18]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[9], at[19]); + COMBA_STORE(C->dp[18]); + COMBA_STORE2(C->dp[19]); + C->used = 20; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 11: + memcpy(at, A->dp, 11 * sizeof(fp_digit)); + memcpy(at+11, B->dp, 11 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[11]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[12]); MULADD(at[1], at[11]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[13]); MULADD(at[1], at[12]); MULADD(at[2], at[11]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[14]); MULADD(at[1], at[13]); MULADD(at[2], at[12]); MULADD(at[3], at[11]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); 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[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); MULADD(at[8], at[11]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); MULADD(at[9], at[11]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); MULADD(at[9], at[12]); MULADD(at[10], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); MULADD(at[10], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); MULADD(at[10], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[10], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[7], at[21]); MULADD(at[8], at[20]); MULADD(at[9], at[19]); MULADD(at[10], at[18]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[8], at[21]); MULADD(at[9], at[20]); MULADD(at[10], at[19]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[9], at[21]); MULADD(at[10], at[20]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[10], at[21]); + COMBA_STORE(C->dp[20]); + COMBA_STORE2(C->dp[21]); + C->used = 22; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 12: + memcpy(at, A->dp, 12 * sizeof(fp_digit)); + memcpy(at+12, B->dp, 12 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[12]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[13]); MULADD(at[1], at[12]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[14]); MULADD(at[1], at[13]); MULADD(at[2], at[12]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[15]); MULADD(at[1], at[14]); MULADD(at[2], at[13]); MULADD(at[3], at[12]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); MULADD(at[2], at[14]); MULADD(at[3], at[13]); MULADD(at[4], at[12]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); MULADD(at[3], at[14]); MULADD(at[4], at[13]); MULADD(at[5], at[12]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); MULADD(at[4], at[14]); MULADD(at[5], at[13]); MULADD(at[6], at[12]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); MULADD(at[9], at[12]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); MULADD(at[10], at[12]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); MULADD(at[10], at[13]); MULADD(at[11], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); MULADD(at[11], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + 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]); MULADD(at[10], at[15]); MULADD(at[11], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[11], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[8], at[23]); MULADD(at[9], at[22]); MULADD(at[10], at[21]); MULADD(at[11], at[20]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[9], at[23]); MULADD(at[10], at[22]); MULADD(at[11], at[21]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[10], at[23]); MULADD(at[11], at[22]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[11], at[23]); + COMBA_STORE(C->dp[22]); + COMBA_STORE2(C->dp[23]); + C->used = 24; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 13: + memcpy(at, A->dp, 13 * sizeof(fp_digit)); + memcpy(at+13, B->dp, 13 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[13]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[14]); MULADD(at[1], at[13]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[15]); MULADD(at[1], at[14]); MULADD(at[2], at[13]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); MULADD(at[2], at[14]); MULADD(at[3], at[13]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); MULADD(at[3], at[14]); MULADD(at[4], at[13]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); MULADD(at[4], at[14]); MULADD(at[5], at[13]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); MULADD(at[10], at[13]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); MULADD(at[11], at[13]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); MULADD(at[10], at[15]); MULADD(at[11], at[14]); MULADD(at[12], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + 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]); MULADD(at[11], at[15]); MULADD(at[12], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[12], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[9], at[25]); MULADD(at[10], at[24]); MULADD(at[11], at[23]); MULADD(at[12], at[22]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[10], at[25]); MULADD(at[11], at[24]); MULADD(at[12], at[23]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[11], at[25]); MULADD(at[12], at[24]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[12], at[25]); + COMBA_STORE(C->dp[24]); + COMBA_STORE2(C->dp[25]); + C->used = 26; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 14: + memcpy(at, A->dp, 14 * sizeof(fp_digit)); + memcpy(at+14, B->dp, 14 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[14]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[15]); MULADD(at[1], at[14]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); MULADD(at[2], at[14]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); MULADD(at[3], at[14]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); MULADD(at[4], at[14]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[10], at[15]); MULADD(at[11], at[14]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); MULADD(at[11], at[15]); MULADD(at[12], at[14]); + COMBA_STORE(C->dp[12]); + /* 13 */ + 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]); MULADD(at[12], at[15]); MULADD(at[13], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[13], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[10], at[27]); MULADD(at[11], at[26]); MULADD(at[12], at[25]); MULADD(at[13], at[24]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[11], at[27]); MULADD(at[12], at[26]); MULADD(at[13], at[25]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[12], at[27]); MULADD(at[13], at[26]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[13], at[27]); + COMBA_STORE(C->dp[26]); + COMBA_STORE2(C->dp[27]); + C->used = 28; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 15: + memcpy(at, A->dp, 15 * sizeof(fp_digit)); + memcpy(at+15, B->dp, 15 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[15]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); MULADD(at[5], at[15]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); MULADD(at[6], at[15]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); MULADD(at[7], at[15]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[8], at[15]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[9], at[15]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[10], at[15]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[11], at[15]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); MULADD(at[12], at[15]); + COMBA_STORE(C->dp[12]); + /* 13 */ + 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]); MULADD(at[13], at[15]); + COMBA_STORE(C->dp[13]); + /* 14 */ + 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]); MULADD(at[14], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[11], at[29]); MULADD(at[12], at[28]); MULADD(at[13], at[27]); MULADD(at[14], at[26]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[12], at[29]); MULADD(at[13], at[28]); MULADD(at[14], at[27]); + COMBA_STORE(C->dp[26]); + /* 27 */ + COMBA_FORWARD; + MULADD(at[13], at[29]); MULADD(at[14], at[28]); + COMBA_STORE(C->dp[27]); + /* 28 */ + COMBA_FORWARD; + MULADD(at[14], at[29]); + COMBA_STORE(C->dp[28]); + COMBA_STORE2(C->dp[29]); + C->used = 30; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 16: + memcpy(at, A->dp, 16 * sizeof(fp_digit)); + memcpy(at+16, B->dp, 16 * sizeof(fp_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; + fp_clamp(C); + COMBA_FINI; + break; + } } -#endif /* TFM_LARGE */ +#endif #ifdef TFM_HUGE @@ -768,4 +1766,928 @@ void fp_mul_comba32(fp_int *A, fp_int *B, fp_int *C) COMBA_FINI; } +void fp_mul_comba64(fp_int *A, fp_int *B, fp_int *C) +{ + fp_digit c0, c1, c2, at[128]; + + memcpy(at, A->dp, 64 * sizeof(fp_digit)); + memcpy(at+64, B->dp, 64 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[64]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[65]); MULADD(at[1], at[64]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[66]); MULADD(at[1], at[65]); MULADD(at[2], at[64]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[67]); MULADD(at[1], at[66]); MULADD(at[2], at[65]); MULADD(at[3], at[64]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[68]); MULADD(at[1], at[67]); MULADD(at[2], at[66]); MULADD(at[3], at[65]); MULADD(at[4], at[64]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[69]); MULADD(at[1], at[68]); MULADD(at[2], at[67]); MULADD(at[3], at[66]); MULADD(at[4], at[65]); MULADD(at[5], at[64]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[70]); MULADD(at[1], at[69]); MULADD(at[2], at[68]); MULADD(at[3], at[67]); MULADD(at[4], at[66]); MULADD(at[5], at[65]); MULADD(at[6], at[64]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[71]); MULADD(at[1], at[70]); MULADD(at[2], at[69]); MULADD(at[3], at[68]); MULADD(at[4], at[67]); MULADD(at[5], at[66]); MULADD(at[6], at[65]); MULADD(at[7], at[64]); + COMBA_STORE(C->dp[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[72]); MULADD(at[1], at[71]); MULADD(at[2], at[70]); MULADD(at[3], at[69]); MULADD(at[4], at[68]); MULADD(at[5], at[67]); MULADD(at[6], at[66]); MULADD(at[7], at[65]); MULADD(at[8], at[64]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[0], at[73]); MULADD(at[1], at[72]); MULADD(at[2], at[71]); MULADD(at[3], at[70]); MULADD(at[4], at[69]); MULADD(at[5], at[68]); MULADD(at[6], at[67]); MULADD(at[7], at[66]); MULADD(at[8], at[65]); MULADD(at[9], at[64]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[0], at[74]); MULADD(at[1], at[73]); MULADD(at[2], at[72]); MULADD(at[3], at[71]); MULADD(at[4], at[70]); MULADD(at[5], at[69]); MULADD(at[6], at[68]); MULADD(at[7], at[67]); MULADD(at[8], at[66]); MULADD(at[9], at[65]); MULADD(at[10], at[64]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[0], at[75]); MULADD(at[1], at[74]); MULADD(at[2], at[73]); MULADD(at[3], at[72]); MULADD(at[4], at[71]); MULADD(at[5], at[70]); MULADD(at[6], at[69]); MULADD(at[7], at[68]); MULADD(at[8], at[67]); MULADD(at[9], at[66]); MULADD(at[10], at[65]); MULADD(at[11], at[64]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[0], at[76]); MULADD(at[1], at[75]); MULADD(at[2], at[74]); MULADD(at[3], at[73]); MULADD(at[4], at[72]); MULADD(at[5], at[71]); MULADD(at[6], at[70]); MULADD(at[7], at[69]); MULADD(at[8], at[68]); MULADD(at[9], at[67]); MULADD(at[10], at[66]); MULADD(at[11], at[65]); MULADD(at[12], at[64]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + MULADD(at[0], at[77]); MULADD(at[1], at[76]); MULADD(at[2], at[75]); MULADD(at[3], at[74]); MULADD(at[4], at[73]); MULADD(at[5], at[72]); MULADD(at[6], at[71]); MULADD(at[7], at[70]); MULADD(at[8], at[69]); MULADD(at[9], at[68]); MULADD(at[10], at[67]); MULADD(at[11], at[66]); MULADD(at[12], at[65]); MULADD(at[13], at[64]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + MULADD(at[0], at[78]); MULADD(at[1], at[77]); MULADD(at[2], at[76]); MULADD(at[3], at[75]); MULADD(at[4], at[74]); MULADD(at[5], at[73]); MULADD(at[6], at[72]); MULADD(at[7], at[71]); MULADD(at[8], at[70]); MULADD(at[9], at[69]); MULADD(at[10], at[68]); MULADD(at[11], at[67]); MULADD(at[12], at[66]); MULADD(at[13], at[65]); MULADD(at[14], at[64]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + MULADD(at[0], at[79]); MULADD(at[1], at[78]); MULADD(at[2], at[77]); MULADD(at[3], at[76]); MULADD(at[4], at[75]); MULADD(at[5], at[74]); MULADD(at[6], at[73]); MULADD(at[7], at[72]); MULADD(at[8], at[71]); MULADD(at[9], at[70]); MULADD(at[10], at[69]); MULADD(at[11], at[68]); MULADD(at[12], at[67]); MULADD(at[13], at[66]); MULADD(at[14], at[65]); MULADD(at[15], at[64]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[0], at[80]); MULADD(at[1], at[79]); MULADD(at[2], at[78]); MULADD(at[3], at[77]); MULADD(at[4], at[76]); MULADD(at[5], at[75]); MULADD(at[6], at[74]); MULADD(at[7], at[73]); MULADD(at[8], at[72]); MULADD(at[9], at[71]); MULADD(at[10], at[70]); MULADD(at[11], at[69]); MULADD(at[12], at[68]); MULADD(at[13], at[67]); MULADD(at[14], at[66]); MULADD(at[15], at[65]); MULADD(at[16], at[64]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[0], at[81]); MULADD(at[1], at[80]); MULADD(at[2], at[79]); MULADD(at[3], at[78]); MULADD(at[4], at[77]); MULADD(at[5], at[76]); MULADD(at[6], at[75]); MULADD(at[7], at[74]); MULADD(at[8], at[73]); MULADD(at[9], at[72]); MULADD(at[10], at[71]); MULADD(at[11], at[70]); MULADD(at[12], at[69]); MULADD(at[13], at[68]); MULADD(at[14], at[67]); MULADD(at[15], at[66]); MULADD(at[16], at[65]); MULADD(at[17], at[64]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[0], at[82]); MULADD(at[1], at[81]); MULADD(at[2], at[80]); MULADD(at[3], at[79]); MULADD(at[4], at[78]); MULADD(at[5], at[77]); MULADD(at[6], at[76]); MULADD(at[7], at[75]); MULADD(at[8], at[74]); MULADD(at[9], at[73]); MULADD(at[10], at[72]); MULADD(at[11], at[71]); MULADD(at[12], at[70]); MULADD(at[13], at[69]); MULADD(at[14], at[68]); MULADD(at[15], at[67]); MULADD(at[16], at[66]); MULADD(at[17], at[65]); MULADD(at[18], at[64]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[0], at[83]); MULADD(at[1], at[82]); MULADD(at[2], at[81]); MULADD(at[3], at[80]); MULADD(at[4], at[79]); MULADD(at[5], at[78]); MULADD(at[6], at[77]); MULADD(at[7], at[76]); MULADD(at[8], at[75]); MULADD(at[9], at[74]); MULADD(at[10], at[73]); MULADD(at[11], at[72]); MULADD(at[12], at[71]); MULADD(at[13], at[70]); MULADD(at[14], at[69]); MULADD(at[15], at[68]); MULADD(at[16], at[67]); MULADD(at[17], at[66]); MULADD(at[18], at[65]); MULADD(at[19], at[64]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[0], at[84]); MULADD(at[1], at[83]); MULADD(at[2], at[82]); MULADD(at[3], at[81]); MULADD(at[4], at[80]); MULADD(at[5], at[79]); MULADD(at[6], at[78]); MULADD(at[7], at[77]); MULADD(at[8], at[76]); MULADD(at[9], at[75]); MULADD(at[10], at[74]); MULADD(at[11], at[73]); MULADD(at[12], at[72]); MULADD(at[13], at[71]); MULADD(at[14], at[70]); MULADD(at[15], at[69]); MULADD(at[16], at[68]); MULADD(at[17], at[67]); MULADD(at[18], at[66]); MULADD(at[19], at[65]); MULADD(at[20], at[64]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[0], at[85]); MULADD(at[1], at[84]); MULADD(at[2], at[83]); MULADD(at[3], at[82]); MULADD(at[4], at[81]); MULADD(at[5], at[80]); MULADD(at[6], at[79]); MULADD(at[7], at[78]); MULADD(at[8], at[77]); MULADD(at[9], at[76]); MULADD(at[10], at[75]); MULADD(at[11], at[74]); MULADD(at[12], at[73]); MULADD(at[13], at[72]); MULADD(at[14], at[71]); MULADD(at[15], at[70]); MULADD(at[16], at[69]); MULADD(at[17], at[68]); MULADD(at[18], at[67]); MULADD(at[19], at[66]); MULADD(at[20], at[65]); MULADD(at[21], at[64]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[0], at[86]); MULADD(at[1], at[85]); MULADD(at[2], at[84]); MULADD(at[3], at[83]); MULADD(at[4], at[82]); MULADD(at[5], at[81]); MULADD(at[6], at[80]); MULADD(at[7], at[79]); MULADD(at[8], at[78]); MULADD(at[9], at[77]); MULADD(at[10], at[76]); MULADD(at[11], at[75]); MULADD(at[12], at[74]); MULADD(at[13], at[73]); MULADD(at[14], at[72]); MULADD(at[15], at[71]); MULADD(at[16], at[70]); MULADD(at[17], at[69]); MULADD(at[18], at[68]); MULADD(at[19], at[67]); MULADD(at[20], at[66]); MULADD(at[21], at[65]); MULADD(at[22], at[64]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[0], at[87]); MULADD(at[1], at[86]); MULADD(at[2], at[85]); MULADD(at[3], at[84]); MULADD(at[4], at[83]); MULADD(at[5], at[82]); MULADD(at[6], at[81]); MULADD(at[7], at[80]); MULADD(at[8], at[79]); MULADD(at[9], at[78]); MULADD(at[10], at[77]); MULADD(at[11], at[76]); MULADD(at[12], at[75]); MULADD(at[13], at[74]); MULADD(at[14], at[73]); MULADD(at[15], at[72]); MULADD(at[16], at[71]); MULADD(at[17], at[70]); MULADD(at[18], at[69]); MULADD(at[19], at[68]); MULADD(at[20], at[67]); MULADD(at[21], at[66]); MULADD(at[22], at[65]); MULADD(at[23], at[64]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[0], at[88]); MULADD(at[1], at[87]); MULADD(at[2], at[86]); MULADD(at[3], at[85]); MULADD(at[4], at[84]); MULADD(at[5], at[83]); MULADD(at[6], at[82]); MULADD(at[7], at[81]); MULADD(at[8], at[80]); MULADD(at[9], at[79]); MULADD(at[10], at[78]); MULADD(at[11], at[77]); MULADD(at[12], at[76]); MULADD(at[13], at[75]); MULADD(at[14], at[74]); MULADD(at[15], at[73]); MULADD(at[16], at[72]); MULADD(at[17], at[71]); MULADD(at[18], at[70]); MULADD(at[19], at[69]); MULADD(at[20], at[68]); MULADD(at[21], at[67]); MULADD(at[22], at[66]); MULADD(at[23], at[65]); MULADD(at[24], at[64]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[0], at[89]); MULADD(at[1], at[88]); MULADD(at[2], at[87]); MULADD(at[3], at[86]); MULADD(at[4], at[85]); MULADD(at[5], at[84]); MULADD(at[6], at[83]); MULADD(at[7], at[82]); MULADD(at[8], at[81]); MULADD(at[9], at[80]); MULADD(at[10], at[79]); MULADD(at[11], at[78]); MULADD(at[12], at[77]); MULADD(at[13], at[76]); MULADD(at[14], at[75]); MULADD(at[15], at[74]); MULADD(at[16], at[73]); MULADD(at[17], at[72]); MULADD(at[18], at[71]); MULADD(at[19], at[70]); MULADD(at[20], at[69]); MULADD(at[21], at[68]); MULADD(at[22], at[67]); MULADD(at[23], at[66]); MULADD(at[24], at[65]); MULADD(at[25], at[64]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[0], at[90]); MULADD(at[1], at[89]); MULADD(at[2], at[88]); MULADD(at[3], at[87]); MULADD(at[4], at[86]); MULADD(at[5], at[85]); MULADD(at[6], at[84]); MULADD(at[7], at[83]); MULADD(at[8], at[82]); MULADD(at[9], at[81]); MULADD(at[10], at[80]); MULADD(at[11], at[79]); MULADD(at[12], at[78]); MULADD(at[13], at[77]); MULADD(at[14], at[76]); MULADD(at[15], at[75]); MULADD(at[16], at[74]); MULADD(at[17], at[73]); MULADD(at[18], at[72]); MULADD(at[19], at[71]); MULADD(at[20], at[70]); MULADD(at[21], at[69]); MULADD(at[22], at[68]); MULADD(at[23], at[67]); MULADD(at[24], at[66]); MULADD(at[25], at[65]); MULADD(at[26], at[64]); + COMBA_STORE(C->dp[26]); + /* 27 */ + COMBA_FORWARD; + MULADD(at[0], at[91]); MULADD(at[1], at[90]); MULADD(at[2], at[89]); MULADD(at[3], at[88]); MULADD(at[4], at[87]); MULADD(at[5], at[86]); MULADD(at[6], at[85]); MULADD(at[7], at[84]); MULADD(at[8], at[83]); MULADD(at[9], at[82]); MULADD(at[10], at[81]); MULADD(at[11], at[80]); MULADD(at[12], at[79]); MULADD(at[13], at[78]); MULADD(at[14], at[77]); MULADD(at[15], at[76]); MULADD(at[16], at[75]); MULADD(at[17], at[74]); MULADD(at[18], at[73]); MULADD(at[19], at[72]); MULADD(at[20], at[71]); MULADD(at[21], at[70]); MULADD(at[22], at[69]); MULADD(at[23], at[68]); MULADD(at[24], at[67]); MULADD(at[25], at[66]); MULADD(at[26], at[65]); MULADD(at[27], at[64]); + COMBA_STORE(C->dp[27]); + /* 28 */ + COMBA_FORWARD; + MULADD(at[0], at[92]); MULADD(at[1], at[91]); MULADD(at[2], at[90]); MULADD(at[3], at[89]); MULADD(at[4], at[88]); MULADD(at[5], at[87]); MULADD(at[6], at[86]); MULADD(at[7], at[85]); MULADD(at[8], at[84]); MULADD(at[9], at[83]); MULADD(at[10], at[82]); MULADD(at[11], at[81]); MULADD(at[12], at[80]); MULADD(at[13], at[79]); MULADD(at[14], at[78]); MULADD(at[15], at[77]); MULADD(at[16], at[76]); MULADD(at[17], at[75]); MULADD(at[18], at[74]); MULADD(at[19], at[73]); MULADD(at[20], at[72]); MULADD(at[21], at[71]); MULADD(at[22], at[70]); MULADD(at[23], at[69]); MULADD(at[24], at[68]); MULADD(at[25], at[67]); MULADD(at[26], at[66]); MULADD(at[27], at[65]); MULADD(at[28], at[64]); + COMBA_STORE(C->dp[28]); + /* 29 */ + COMBA_FORWARD; + MULADD(at[0], at[93]); MULADD(at[1], at[92]); MULADD(at[2], at[91]); MULADD(at[3], at[90]); MULADD(at[4], at[89]); MULADD(at[5], at[88]); MULADD(at[6], at[87]); MULADD(at[7], at[86]); MULADD(at[8], at[85]); MULADD(at[9], at[84]); MULADD(at[10], at[83]); MULADD(at[11], at[82]); MULADD(at[12], at[81]); MULADD(at[13], at[80]); MULADD(at[14], at[79]); MULADD(at[15], at[78]); MULADD(at[16], at[77]); MULADD(at[17], at[76]); MULADD(at[18], at[75]); MULADD(at[19], at[74]); MULADD(at[20], at[73]); MULADD(at[21], at[72]); MULADD(at[22], at[71]); MULADD(at[23], at[70]); MULADD(at[24], at[69]); MULADD(at[25], at[68]); MULADD(at[26], at[67]); MULADD(at[27], at[66]); MULADD(at[28], at[65]); MULADD(at[29], at[64]); + COMBA_STORE(C->dp[29]); + /* 30 */ + COMBA_FORWARD; + MULADD(at[0], at[94]); MULADD(at[1], at[93]); MULADD(at[2], at[92]); MULADD(at[3], at[91]); MULADD(at[4], at[90]); MULADD(at[5], at[89]); MULADD(at[6], at[88]); MULADD(at[7], at[87]); MULADD(at[8], at[86]); MULADD(at[9], at[85]); MULADD(at[10], at[84]); MULADD(at[11], at[83]); MULADD(at[12], at[82]); MULADD(at[13], at[81]); MULADD(at[14], at[80]); MULADD(at[15], at[79]); MULADD(at[16], at[78]); MULADD(at[17], at[77]); MULADD(at[18], at[76]); MULADD(at[19], at[75]); MULADD(at[20], at[74]); MULADD(at[21], at[73]); MULADD(at[22], at[72]); MULADD(at[23], at[71]); MULADD(at[24], at[70]); MULADD(at[25], at[69]); MULADD(at[26], at[68]); MULADD(at[27], at[67]); MULADD(at[28], at[66]); MULADD(at[29], at[65]); MULADD(at[30], at[64]); + COMBA_STORE(C->dp[30]); + /* 31 */ + COMBA_FORWARD; + MULADD(at[0], at[95]); MULADD(at[1], at[94]); MULADD(at[2], at[93]); MULADD(at[3], at[92]); MULADD(at[4], at[91]); MULADD(at[5], at[90]); MULADD(at[6], at[89]); MULADD(at[7], at[88]); MULADD(at[8], at[87]); MULADD(at[9], at[86]); MULADD(at[10], at[85]); MULADD(at[11], at[84]); MULADD(at[12], at[83]); MULADD(at[13], at[82]); MULADD(at[14], at[81]); MULADD(at[15], at[80]); MULADD(at[16], at[79]); MULADD(at[17], at[78]); MULADD(at[18], at[77]); MULADD(at[19], at[76]); MULADD(at[20], at[75]); MULADD(at[21], at[74]); MULADD(at[22], at[73]); MULADD(at[23], at[72]); MULADD(at[24], at[71]); MULADD(at[25], at[70]); MULADD(at[26], at[69]); MULADD(at[27], at[68]); MULADD(at[28], at[67]); MULADD(at[29], at[66]); MULADD(at[30], at[65]); MULADD(at[31], at[64]); + COMBA_STORE(C->dp[31]); + /* 32 */ + COMBA_FORWARD; + MULADD(at[0], at[96]); MULADD(at[1], at[95]); MULADD(at[2], at[94]); MULADD(at[3], at[93]); MULADD(at[4], at[92]); MULADD(at[5], at[91]); MULADD(at[6], at[90]); MULADD(at[7], at[89]); MULADD(at[8], at[88]); MULADD(at[9], at[87]); MULADD(at[10], at[86]); MULADD(at[11], at[85]); MULADD(at[12], at[84]); MULADD(at[13], at[83]); MULADD(at[14], at[82]); MULADD(at[15], at[81]); MULADD(at[16], at[80]); MULADD(at[17], at[79]); MULADD(at[18], at[78]); MULADD(at[19], at[77]); MULADD(at[20], at[76]); MULADD(at[21], at[75]); MULADD(at[22], at[74]); MULADD(at[23], at[73]); MULADD(at[24], at[72]); MULADD(at[25], at[71]); MULADD(at[26], at[70]); MULADD(at[27], at[69]); MULADD(at[28], at[68]); MULADD(at[29], at[67]); MULADD(at[30], at[66]); MULADD(at[31], at[65]); MULADD(at[32], at[64]); + COMBA_STORE(C->dp[32]); + /* 33 */ + COMBA_FORWARD; + MULADD(at[0], at[97]); MULADD(at[1], at[96]); MULADD(at[2], at[95]); MULADD(at[3], at[94]); MULADD(at[4], at[93]); MULADD(at[5], at[92]); MULADD(at[6], at[91]); MULADD(at[7], at[90]); MULADD(at[8], at[89]); MULADD(at[9], at[88]); MULADD(at[10], at[87]); MULADD(at[11], at[86]); MULADD(at[12], at[85]); MULADD(at[13], at[84]); MULADD(at[14], at[83]); MULADD(at[15], at[82]); MULADD(at[16], at[81]); MULADD(at[17], at[80]); MULADD(at[18], at[79]); MULADD(at[19], at[78]); MULADD(at[20], at[77]); MULADD(at[21], at[76]); MULADD(at[22], at[75]); MULADD(at[23], at[74]); MULADD(at[24], at[73]); MULADD(at[25], at[72]); MULADD(at[26], at[71]); MULADD(at[27], at[70]); MULADD(at[28], at[69]); MULADD(at[29], at[68]); MULADD(at[30], at[67]); MULADD(at[31], at[66]); MULADD(at[32], at[65]); MULADD(at[33], at[64]); + COMBA_STORE(C->dp[33]); + /* 34 */ + COMBA_FORWARD; + MULADD(at[0], at[98]); MULADD(at[1], at[97]); MULADD(at[2], at[96]); MULADD(at[3], at[95]); MULADD(at[4], at[94]); MULADD(at[5], at[93]); MULADD(at[6], at[92]); MULADD(at[7], at[91]); MULADD(at[8], at[90]); MULADD(at[9], at[89]); MULADD(at[10], at[88]); MULADD(at[11], at[87]); MULADD(at[12], at[86]); MULADD(at[13], at[85]); MULADD(at[14], at[84]); MULADD(at[15], at[83]); MULADD(at[16], at[82]); MULADD(at[17], at[81]); MULADD(at[18], at[80]); MULADD(at[19], at[79]); MULADD(at[20], at[78]); MULADD(at[21], at[77]); MULADD(at[22], at[76]); MULADD(at[23], at[75]); MULADD(at[24], at[74]); MULADD(at[25], at[73]); MULADD(at[26], at[72]); MULADD(at[27], at[71]); MULADD(at[28], at[70]); MULADD(at[29], at[69]); MULADD(at[30], at[68]); MULADD(at[31], at[67]); MULADD(at[32], at[66]); MULADD(at[33], at[65]); MULADD(at[34], at[64]); + COMBA_STORE(C->dp[34]); + /* 35 */ + COMBA_FORWARD; + MULADD(at[0], at[99]); MULADD(at[1], at[98]); MULADD(at[2], at[97]); MULADD(at[3], at[96]); MULADD(at[4], at[95]); MULADD(at[5], at[94]); MULADD(at[6], at[93]); MULADD(at[7], at[92]); MULADD(at[8], at[91]); MULADD(at[9], at[90]); MULADD(at[10], at[89]); MULADD(at[11], at[88]); MULADD(at[12], at[87]); MULADD(at[13], at[86]); MULADD(at[14], at[85]); MULADD(at[15], at[84]); MULADD(at[16], at[83]); MULADD(at[17], at[82]); MULADD(at[18], at[81]); MULADD(at[19], at[80]); MULADD(at[20], at[79]); MULADD(at[21], at[78]); MULADD(at[22], at[77]); MULADD(at[23], at[76]); MULADD(at[24], at[75]); MULADD(at[25], at[74]); MULADD(at[26], at[73]); MULADD(at[27], at[72]); MULADD(at[28], at[71]); MULADD(at[29], at[70]); MULADD(at[30], at[69]); MULADD(at[31], at[68]); MULADD(at[32], at[67]); MULADD(at[33], at[66]); MULADD(at[34], at[65]); MULADD(at[35], at[64]); + COMBA_STORE(C->dp[35]); + /* 36 */ + COMBA_FORWARD; + MULADD(at[0], at[100]); MULADD(at[1], at[99]); MULADD(at[2], at[98]); MULADD(at[3], at[97]); MULADD(at[4], at[96]); MULADD(at[5], at[95]); MULADD(at[6], at[94]); MULADD(at[7], at[93]); MULADD(at[8], at[92]); MULADD(at[9], at[91]); MULADD(at[10], at[90]); MULADD(at[11], at[89]); MULADD(at[12], at[88]); MULADD(at[13], at[87]); MULADD(at[14], at[86]); MULADD(at[15], at[85]); MULADD(at[16], at[84]); MULADD(at[17], at[83]); MULADD(at[18], at[82]); MULADD(at[19], at[81]); MULADD(at[20], at[80]); MULADD(at[21], at[79]); MULADD(at[22], at[78]); MULADD(at[23], at[77]); MULADD(at[24], at[76]); MULADD(at[25], at[75]); MULADD(at[26], at[74]); MULADD(at[27], at[73]); MULADD(at[28], at[72]); MULADD(at[29], at[71]); MULADD(at[30], at[70]); MULADD(at[31], at[69]); MULADD(at[32], at[68]); MULADD(at[33], at[67]); MULADD(at[34], at[66]); MULADD(at[35], at[65]); MULADD(at[36], at[64]); + COMBA_STORE(C->dp[36]); + /* 37 */ + COMBA_FORWARD; + MULADD(at[0], at[101]); MULADD(at[1], at[100]); MULADD(at[2], at[99]); MULADD(at[3], at[98]); MULADD(at[4], at[97]); MULADD(at[5], at[96]); MULADD(at[6], at[95]); MULADD(at[7], at[94]); MULADD(at[8], at[93]); MULADD(at[9], at[92]); MULADD(at[10], at[91]); MULADD(at[11], at[90]); MULADD(at[12], at[89]); MULADD(at[13], at[88]); MULADD(at[14], at[87]); MULADD(at[15], at[86]); MULADD(at[16], at[85]); MULADD(at[17], at[84]); MULADD(at[18], at[83]); MULADD(at[19], at[82]); MULADD(at[20], at[81]); MULADD(at[21], at[80]); MULADD(at[22], at[79]); MULADD(at[23], at[78]); MULADD(at[24], at[77]); MULADD(at[25], at[76]); MULADD(at[26], at[75]); MULADD(at[27], at[74]); MULADD(at[28], at[73]); MULADD(at[29], at[72]); MULADD(at[30], at[71]); MULADD(at[31], at[70]); MULADD(at[32], at[69]); MULADD(at[33], at[68]); MULADD(at[34], at[67]); MULADD(at[35], at[66]); MULADD(at[36], at[65]); MULADD(at[37], at[64]); + COMBA_STORE(C->dp[37]); + /* 38 */ + COMBA_FORWARD; + MULADD(at[0], at[102]); MULADD(at[1], at[101]); MULADD(at[2], at[100]); MULADD(at[3], at[99]); MULADD(at[4], at[98]); MULADD(at[5], at[97]); MULADD(at[6], at[96]); MULADD(at[7], at[95]); MULADD(at[8], at[94]); MULADD(at[9], at[93]); MULADD(at[10], at[92]); MULADD(at[11], at[91]); MULADD(at[12], at[90]); MULADD(at[13], at[89]); MULADD(at[14], at[88]); MULADD(at[15], at[87]); MULADD(at[16], at[86]); MULADD(at[17], at[85]); MULADD(at[18], at[84]); MULADD(at[19], at[83]); MULADD(at[20], at[82]); MULADD(at[21], at[81]); MULADD(at[22], at[80]); MULADD(at[23], at[79]); MULADD(at[24], at[78]); MULADD(at[25], at[77]); MULADD(at[26], at[76]); MULADD(at[27], at[75]); MULADD(at[28], at[74]); MULADD(at[29], at[73]); MULADD(at[30], at[72]); MULADD(at[31], at[71]); MULADD(at[32], at[70]); MULADD(at[33], at[69]); MULADD(at[34], at[68]); MULADD(at[35], at[67]); MULADD(at[36], at[66]); MULADD(at[37], at[65]); MULADD(at[38], at[64]); + COMBA_STORE(C->dp[38]); + /* 39 */ + COMBA_FORWARD; + MULADD(at[0], at[103]); MULADD(at[1], at[102]); MULADD(at[2], at[101]); MULADD(at[3], at[100]); MULADD(at[4], at[99]); MULADD(at[5], at[98]); MULADD(at[6], at[97]); MULADD(at[7], at[96]); MULADD(at[8], at[95]); MULADD(at[9], at[94]); MULADD(at[10], at[93]); MULADD(at[11], at[92]); MULADD(at[12], at[91]); MULADD(at[13], at[90]); MULADD(at[14], at[89]); MULADD(at[15], at[88]); MULADD(at[16], at[87]); MULADD(at[17], at[86]); MULADD(at[18], at[85]); MULADD(at[19], at[84]); MULADD(at[20], at[83]); MULADD(at[21], at[82]); MULADD(at[22], at[81]); MULADD(at[23], at[80]); MULADD(at[24], at[79]); MULADD(at[25], at[78]); MULADD(at[26], at[77]); MULADD(at[27], at[76]); MULADD(at[28], at[75]); MULADD(at[29], at[74]); MULADD(at[30], at[73]); MULADD(at[31], at[72]); MULADD(at[32], at[71]); MULADD(at[33], at[70]); MULADD(at[34], at[69]); MULADD(at[35], at[68]); MULADD(at[36], at[67]); MULADD(at[37], at[66]); MULADD(at[38], at[65]); MULADD(at[39], at[64]); + COMBA_STORE(C->dp[39]); + /* 40 */ + COMBA_FORWARD; + MULADD(at[0], at[104]); MULADD(at[1], at[103]); MULADD(at[2], at[102]); MULADD(at[3], at[101]); MULADD(at[4], at[100]); MULADD(at[5], at[99]); MULADD(at[6], at[98]); MULADD(at[7], at[97]); MULADD(at[8], at[96]); MULADD(at[9], at[95]); MULADD(at[10], at[94]); MULADD(at[11], at[93]); MULADD(at[12], at[92]); MULADD(at[13], at[91]); MULADD(at[14], at[90]); MULADD(at[15], at[89]); MULADD(at[16], at[88]); MULADD(at[17], at[87]); MULADD(at[18], at[86]); MULADD(at[19], at[85]); MULADD(at[20], at[84]); MULADD(at[21], at[83]); MULADD(at[22], at[82]); MULADD(at[23], at[81]); MULADD(at[24], at[80]); MULADD(at[25], at[79]); MULADD(at[26], at[78]); MULADD(at[27], at[77]); MULADD(at[28], at[76]); MULADD(at[29], at[75]); MULADD(at[30], at[74]); MULADD(at[31], at[73]); MULADD(at[32], at[72]); MULADD(at[33], at[71]); MULADD(at[34], at[70]); MULADD(at[35], at[69]); MULADD(at[36], at[68]); MULADD(at[37], at[67]); MULADD(at[38], at[66]); MULADD(at[39], at[65]); MULADD(at[40], at[64]); + COMBA_STORE(C->dp[40]); + /* 41 */ + COMBA_FORWARD; + MULADD(at[0], at[105]); MULADD(at[1], at[104]); MULADD(at[2], at[103]); MULADD(at[3], at[102]); MULADD(at[4], at[101]); MULADD(at[5], at[100]); MULADD(at[6], at[99]); MULADD(at[7], at[98]); MULADD(at[8], at[97]); MULADD(at[9], at[96]); MULADD(at[10], at[95]); MULADD(at[11], at[94]); MULADD(at[12], at[93]); MULADD(at[13], at[92]); MULADD(at[14], at[91]); MULADD(at[15], at[90]); MULADD(at[16], at[89]); MULADD(at[17], at[88]); MULADD(at[18], at[87]); MULADD(at[19], at[86]); MULADD(at[20], at[85]); MULADD(at[21], at[84]); MULADD(at[22], at[83]); MULADD(at[23], at[82]); MULADD(at[24], at[81]); MULADD(at[25], at[80]); MULADD(at[26], at[79]); MULADD(at[27], at[78]); MULADD(at[28], at[77]); MULADD(at[29], at[76]); MULADD(at[30], at[75]); MULADD(at[31], at[74]); MULADD(at[32], at[73]); MULADD(at[33], at[72]); MULADD(at[34], at[71]); MULADD(at[35], at[70]); MULADD(at[36], at[69]); MULADD(at[37], at[68]); MULADD(at[38], at[67]); MULADD(at[39], at[66]); MULADD(at[40], at[65]); MULADD(at[41], at[64]); + COMBA_STORE(C->dp[41]); + /* 42 */ + COMBA_FORWARD; + MULADD(at[0], at[106]); MULADD(at[1], at[105]); MULADD(at[2], at[104]); MULADD(at[3], at[103]); MULADD(at[4], at[102]); MULADD(at[5], at[101]); MULADD(at[6], at[100]); MULADD(at[7], at[99]); MULADD(at[8], at[98]); MULADD(at[9], at[97]); MULADD(at[10], at[96]); MULADD(at[11], at[95]); MULADD(at[12], at[94]); MULADD(at[13], at[93]); MULADD(at[14], at[92]); MULADD(at[15], at[91]); MULADD(at[16], at[90]); MULADD(at[17], at[89]); MULADD(at[18], at[88]); MULADD(at[19], at[87]); MULADD(at[20], at[86]); MULADD(at[21], at[85]); MULADD(at[22], at[84]); MULADD(at[23], at[83]); MULADD(at[24], at[82]); MULADD(at[25], at[81]); MULADD(at[26], at[80]); MULADD(at[27], at[79]); MULADD(at[28], at[78]); MULADD(at[29], at[77]); MULADD(at[30], at[76]); MULADD(at[31], at[75]); MULADD(at[32], at[74]); MULADD(at[33], at[73]); MULADD(at[34], at[72]); MULADD(at[35], at[71]); MULADD(at[36], at[70]); MULADD(at[37], at[69]); MULADD(at[38], at[68]); MULADD(at[39], at[67]); MULADD(at[40], at[66]); MULADD(at[41], at[65]); MULADD(at[42], at[64]); + COMBA_STORE(C->dp[42]); + /* 43 */ + COMBA_FORWARD; + MULADD(at[0], at[107]); MULADD(at[1], at[106]); MULADD(at[2], at[105]); MULADD(at[3], at[104]); MULADD(at[4], at[103]); MULADD(at[5], at[102]); MULADD(at[6], at[101]); MULADD(at[7], at[100]); MULADD(at[8], at[99]); MULADD(at[9], at[98]); MULADD(at[10], at[97]); MULADD(at[11], at[96]); MULADD(at[12], at[95]); MULADD(at[13], at[94]); MULADD(at[14], at[93]); MULADD(at[15], at[92]); MULADD(at[16], at[91]); MULADD(at[17], at[90]); MULADD(at[18], at[89]); MULADD(at[19], at[88]); MULADD(at[20], at[87]); MULADD(at[21], at[86]); MULADD(at[22], at[85]); MULADD(at[23], at[84]); MULADD(at[24], at[83]); MULADD(at[25], at[82]); MULADD(at[26], at[81]); MULADD(at[27], at[80]); MULADD(at[28], at[79]); MULADD(at[29], at[78]); MULADD(at[30], at[77]); MULADD(at[31], at[76]); MULADD(at[32], at[75]); MULADD(at[33], at[74]); MULADD(at[34], at[73]); MULADD(at[35], at[72]); MULADD(at[36], at[71]); MULADD(at[37], at[70]); MULADD(at[38], at[69]); MULADD(at[39], at[68]); MULADD(at[40], at[67]); MULADD(at[41], at[66]); MULADD(at[42], at[65]); MULADD(at[43], at[64]); + COMBA_STORE(C->dp[43]); + /* 44 */ + COMBA_FORWARD; + MULADD(at[0], at[108]); MULADD(at[1], at[107]); MULADD(at[2], at[106]); MULADD(at[3], at[105]); MULADD(at[4], at[104]); MULADD(at[5], at[103]); MULADD(at[6], at[102]); MULADD(at[7], at[101]); MULADD(at[8], at[100]); MULADD(at[9], at[99]); MULADD(at[10], at[98]); MULADD(at[11], at[97]); MULADD(at[12], at[96]); MULADD(at[13], at[95]); MULADD(at[14], at[94]); MULADD(at[15], at[93]); MULADD(at[16], at[92]); MULADD(at[17], at[91]); MULADD(at[18], at[90]); MULADD(at[19], at[89]); MULADD(at[20], at[88]); MULADD(at[21], at[87]); MULADD(at[22], at[86]); MULADD(at[23], at[85]); MULADD(at[24], at[84]); MULADD(at[25], at[83]); MULADD(at[26], at[82]); MULADD(at[27], at[81]); MULADD(at[28], at[80]); MULADD(at[29], at[79]); MULADD(at[30], at[78]); MULADD(at[31], at[77]); MULADD(at[32], at[76]); MULADD(at[33], at[75]); MULADD(at[34], at[74]); MULADD(at[35], at[73]); MULADD(at[36], at[72]); MULADD(at[37], at[71]); MULADD(at[38], at[70]); MULADD(at[39], at[69]); MULADD(at[40], at[68]); MULADD(at[41], at[67]); MULADD(at[42], at[66]); MULADD(at[43], at[65]); MULADD(at[44], at[64]); + COMBA_STORE(C->dp[44]); + /* 45 */ + COMBA_FORWARD; + MULADD(at[0], at[109]); MULADD(at[1], at[108]); MULADD(at[2], at[107]); MULADD(at[3], at[106]); MULADD(at[4], at[105]); MULADD(at[5], at[104]); MULADD(at[6], at[103]); MULADD(at[7], at[102]); MULADD(at[8], at[101]); MULADD(at[9], at[100]); MULADD(at[10], at[99]); MULADD(at[11], at[98]); MULADD(at[12], at[97]); MULADD(at[13], at[96]); MULADD(at[14], at[95]); MULADD(at[15], at[94]); MULADD(at[16], at[93]); MULADD(at[17], at[92]); MULADD(at[18], at[91]); MULADD(at[19], at[90]); MULADD(at[20], at[89]); MULADD(at[21], at[88]); MULADD(at[22], at[87]); MULADD(at[23], at[86]); MULADD(at[24], at[85]); MULADD(at[25], at[84]); MULADD(at[26], at[83]); MULADD(at[27], at[82]); MULADD(at[28], at[81]); MULADD(at[29], at[80]); MULADD(at[30], at[79]); MULADD(at[31], at[78]); MULADD(at[32], at[77]); MULADD(at[33], at[76]); MULADD(at[34], at[75]); MULADD(at[35], at[74]); MULADD(at[36], at[73]); MULADD(at[37], at[72]); MULADD(at[38], at[71]); MULADD(at[39], at[70]); MULADD(at[40], at[69]); MULADD(at[41], at[68]); MULADD(at[42], at[67]); MULADD(at[43], at[66]); MULADD(at[44], at[65]); MULADD(at[45], at[64]); + COMBA_STORE(C->dp[45]); + /* 46 */ + COMBA_FORWARD; + MULADD(at[0], at[110]); MULADD(at[1], at[109]); MULADD(at[2], at[108]); MULADD(at[3], at[107]); MULADD(at[4], at[106]); MULADD(at[5], at[105]); MULADD(at[6], at[104]); MULADD(at[7], at[103]); MULADD(at[8], at[102]); MULADD(at[9], at[101]); MULADD(at[10], at[100]); MULADD(at[11], at[99]); MULADD(at[12], at[98]); MULADD(at[13], at[97]); MULADD(at[14], at[96]); MULADD(at[15], at[95]); MULADD(at[16], at[94]); MULADD(at[17], at[93]); MULADD(at[18], at[92]); MULADD(at[19], at[91]); MULADD(at[20], at[90]); MULADD(at[21], at[89]); MULADD(at[22], at[88]); MULADD(at[23], at[87]); MULADD(at[24], at[86]); MULADD(at[25], at[85]); MULADD(at[26], at[84]); MULADD(at[27], at[83]); MULADD(at[28], at[82]); MULADD(at[29], at[81]); MULADD(at[30], at[80]); MULADD(at[31], at[79]); MULADD(at[32], at[78]); MULADD(at[33], at[77]); MULADD(at[34], at[76]); MULADD(at[35], at[75]); MULADD(at[36], at[74]); MULADD(at[37], at[73]); MULADD(at[38], at[72]); MULADD(at[39], at[71]); MULADD(at[40], at[70]); MULADD(at[41], at[69]); MULADD(at[42], at[68]); MULADD(at[43], at[67]); MULADD(at[44], at[66]); MULADD(at[45], at[65]); MULADD(at[46], at[64]); + COMBA_STORE(C->dp[46]); + /* 47 */ + COMBA_FORWARD; + MULADD(at[0], at[111]); MULADD(at[1], at[110]); MULADD(at[2], at[109]); MULADD(at[3], at[108]); MULADD(at[4], at[107]); MULADD(at[5], at[106]); MULADD(at[6], at[105]); MULADD(at[7], at[104]); MULADD(at[8], at[103]); MULADD(at[9], at[102]); MULADD(at[10], at[101]); MULADD(at[11], at[100]); MULADD(at[12], at[99]); MULADD(at[13], at[98]); MULADD(at[14], at[97]); MULADD(at[15], at[96]); MULADD(at[16], at[95]); MULADD(at[17], at[94]); MULADD(at[18], at[93]); MULADD(at[19], at[92]); MULADD(at[20], at[91]); MULADD(at[21], at[90]); MULADD(at[22], at[89]); MULADD(at[23], at[88]); MULADD(at[24], at[87]); MULADD(at[25], at[86]); MULADD(at[26], at[85]); MULADD(at[27], at[84]); MULADD(at[28], at[83]); MULADD(at[29], at[82]); MULADD(at[30], at[81]); MULADD(at[31], at[80]); MULADD(at[32], at[79]); MULADD(at[33], at[78]); MULADD(at[34], at[77]); MULADD(at[35], at[76]); MULADD(at[36], at[75]); MULADD(at[37], at[74]); MULADD(at[38], at[73]); MULADD(at[39], at[72]); MULADD(at[40], at[71]); MULADD(at[41], at[70]); MULADD(at[42], at[69]); MULADD(at[43], at[68]); MULADD(at[44], at[67]); MULADD(at[45], at[66]); MULADD(at[46], at[65]); MULADD(at[47], at[64]); + COMBA_STORE(C->dp[47]); + /* 48 */ + COMBA_FORWARD; + MULADD(at[0], at[112]); MULADD(at[1], at[111]); MULADD(at[2], at[110]); MULADD(at[3], at[109]); MULADD(at[4], at[108]); MULADD(at[5], at[107]); MULADD(at[6], at[106]); MULADD(at[7], at[105]); MULADD(at[8], at[104]); MULADD(at[9], at[103]); MULADD(at[10], at[102]); MULADD(at[11], at[101]); MULADD(at[12], at[100]); MULADD(at[13], at[99]); MULADD(at[14], at[98]); MULADD(at[15], at[97]); MULADD(at[16], at[96]); MULADD(at[17], at[95]); MULADD(at[18], at[94]); MULADD(at[19], at[93]); MULADD(at[20], at[92]); MULADD(at[21], at[91]); MULADD(at[22], at[90]); MULADD(at[23], at[89]); MULADD(at[24], at[88]); MULADD(at[25], at[87]); MULADD(at[26], at[86]); MULADD(at[27], at[85]); MULADD(at[28], at[84]); MULADD(at[29], at[83]); MULADD(at[30], at[82]); MULADD(at[31], at[81]); MULADD(at[32], at[80]); MULADD(at[33], at[79]); MULADD(at[34], at[78]); MULADD(at[35], at[77]); MULADD(at[36], at[76]); MULADD(at[37], at[75]); MULADD(at[38], at[74]); MULADD(at[39], at[73]); MULADD(at[40], at[72]); MULADD(at[41], at[71]); MULADD(at[42], at[70]); MULADD(at[43], at[69]); MULADD(at[44], at[68]); MULADD(at[45], at[67]); MULADD(at[46], at[66]); MULADD(at[47], at[65]); MULADD(at[48], at[64]); + COMBA_STORE(C->dp[48]); + /* 49 */ + COMBA_FORWARD; + MULADD(at[0], at[113]); MULADD(at[1], at[112]); MULADD(at[2], at[111]); MULADD(at[3], at[110]); MULADD(at[4], at[109]); MULADD(at[5], at[108]); MULADD(at[6], at[107]); MULADD(at[7], at[106]); MULADD(at[8], at[105]); MULADD(at[9], at[104]); MULADD(at[10], at[103]); MULADD(at[11], at[102]); MULADD(at[12], at[101]); MULADD(at[13], at[100]); MULADD(at[14], at[99]); MULADD(at[15], at[98]); MULADD(at[16], at[97]); MULADD(at[17], at[96]); MULADD(at[18], at[95]); MULADD(at[19], at[94]); MULADD(at[20], at[93]); MULADD(at[21], at[92]); MULADD(at[22], at[91]); MULADD(at[23], at[90]); MULADD(at[24], at[89]); MULADD(at[25], at[88]); MULADD(at[26], at[87]); MULADD(at[27], at[86]); MULADD(at[28], at[85]); MULADD(at[29], at[84]); MULADD(at[30], at[83]); MULADD(at[31], at[82]); MULADD(at[32], at[81]); MULADD(at[33], at[80]); MULADD(at[34], at[79]); MULADD(at[35], at[78]); MULADD(at[36], at[77]); MULADD(at[37], at[76]); MULADD(at[38], at[75]); MULADD(at[39], at[74]); MULADD(at[40], at[73]); MULADD(at[41], at[72]); MULADD(at[42], at[71]); MULADD(at[43], at[70]); MULADD(at[44], at[69]); MULADD(at[45], at[68]); MULADD(at[46], at[67]); MULADD(at[47], at[66]); MULADD(at[48], at[65]); MULADD(at[49], at[64]); + COMBA_STORE(C->dp[49]); + /* 50 */ + COMBA_FORWARD; + MULADD(at[0], at[114]); MULADD(at[1], at[113]); MULADD(at[2], at[112]); MULADD(at[3], at[111]); MULADD(at[4], at[110]); MULADD(at[5], at[109]); MULADD(at[6], at[108]); MULADD(at[7], at[107]); MULADD(at[8], at[106]); MULADD(at[9], at[105]); MULADD(at[10], at[104]); MULADD(at[11], at[103]); MULADD(at[12], at[102]); MULADD(at[13], at[101]); MULADD(at[14], at[100]); MULADD(at[15], at[99]); MULADD(at[16], at[98]); MULADD(at[17], at[97]); MULADD(at[18], at[96]); MULADD(at[19], at[95]); MULADD(at[20], at[94]); MULADD(at[21], at[93]); MULADD(at[22], at[92]); MULADD(at[23], at[91]); MULADD(at[24], at[90]); MULADD(at[25], at[89]); MULADD(at[26], at[88]); MULADD(at[27], at[87]); MULADD(at[28], at[86]); MULADD(at[29], at[85]); MULADD(at[30], at[84]); MULADD(at[31], at[83]); MULADD(at[32], at[82]); MULADD(at[33], at[81]); MULADD(at[34], at[80]); MULADD(at[35], at[79]); MULADD(at[36], at[78]); MULADD(at[37], at[77]); MULADD(at[38], at[76]); MULADD(at[39], at[75]); MULADD(at[40], at[74]); MULADD(at[41], at[73]); MULADD(at[42], at[72]); MULADD(at[43], at[71]); MULADD(at[44], at[70]); MULADD(at[45], at[69]); MULADD(at[46], at[68]); MULADD(at[47], at[67]); MULADD(at[48], at[66]); MULADD(at[49], at[65]); MULADD(at[50], at[64]); + COMBA_STORE(C->dp[50]); + /* 51 */ + COMBA_FORWARD; + MULADD(at[0], at[115]); MULADD(at[1], at[114]); MULADD(at[2], at[113]); MULADD(at[3], at[112]); MULADD(at[4], at[111]); MULADD(at[5], at[110]); MULADD(at[6], at[109]); MULADD(at[7], at[108]); MULADD(at[8], at[107]); MULADD(at[9], at[106]); MULADD(at[10], at[105]); MULADD(at[11], at[104]); MULADD(at[12], at[103]); MULADD(at[13], at[102]); MULADD(at[14], at[101]); MULADD(at[15], at[100]); MULADD(at[16], at[99]); MULADD(at[17], at[98]); MULADD(at[18], at[97]); MULADD(at[19], at[96]); MULADD(at[20], at[95]); MULADD(at[21], at[94]); MULADD(at[22], at[93]); MULADD(at[23], at[92]); MULADD(at[24], at[91]); MULADD(at[25], at[90]); MULADD(at[26], at[89]); MULADD(at[27], at[88]); MULADD(at[28], at[87]); MULADD(at[29], at[86]); MULADD(at[30], at[85]); MULADD(at[31], at[84]); MULADD(at[32], at[83]); MULADD(at[33], at[82]); MULADD(at[34], at[81]); MULADD(at[35], at[80]); MULADD(at[36], at[79]); MULADD(at[37], at[78]); MULADD(at[38], at[77]); MULADD(at[39], at[76]); MULADD(at[40], at[75]); MULADD(at[41], at[74]); MULADD(at[42], at[73]); MULADD(at[43], at[72]); MULADD(at[44], at[71]); MULADD(at[45], at[70]); MULADD(at[46], at[69]); MULADD(at[47], at[68]); MULADD(at[48], at[67]); MULADD(at[49], at[66]); MULADD(at[50], at[65]); MULADD(at[51], at[64]); + COMBA_STORE(C->dp[51]); + /* 52 */ + COMBA_FORWARD; + MULADD(at[0], at[116]); MULADD(at[1], at[115]); MULADD(at[2], at[114]); MULADD(at[3], at[113]); MULADD(at[4], at[112]); MULADD(at[5], at[111]); MULADD(at[6], at[110]); MULADD(at[7], at[109]); MULADD(at[8], at[108]); MULADD(at[9], at[107]); MULADD(at[10], at[106]); MULADD(at[11], at[105]); MULADD(at[12], at[104]); MULADD(at[13], at[103]); MULADD(at[14], at[102]); MULADD(at[15], at[101]); MULADD(at[16], at[100]); MULADD(at[17], at[99]); MULADD(at[18], at[98]); MULADD(at[19], at[97]); MULADD(at[20], at[96]); MULADD(at[21], at[95]); MULADD(at[22], at[94]); MULADD(at[23], at[93]); MULADD(at[24], at[92]); MULADD(at[25], at[91]); MULADD(at[26], at[90]); MULADD(at[27], at[89]); MULADD(at[28], at[88]); MULADD(at[29], at[87]); MULADD(at[30], at[86]); MULADD(at[31], at[85]); MULADD(at[32], at[84]); MULADD(at[33], at[83]); MULADD(at[34], at[82]); MULADD(at[35], at[81]); MULADD(at[36], at[80]); MULADD(at[37], at[79]); MULADD(at[38], at[78]); MULADD(at[39], at[77]); MULADD(at[40], at[76]); MULADD(at[41], at[75]); MULADD(at[42], at[74]); MULADD(at[43], at[73]); MULADD(at[44], at[72]); MULADD(at[45], at[71]); MULADD(at[46], at[70]); MULADD(at[47], at[69]); MULADD(at[48], at[68]); MULADD(at[49], at[67]); MULADD(at[50], at[66]); MULADD(at[51], at[65]); MULADD(at[52], at[64]); + COMBA_STORE(C->dp[52]); + /* 53 */ + COMBA_FORWARD; + MULADD(at[0], at[117]); MULADD(at[1], at[116]); MULADD(at[2], at[115]); MULADD(at[3], at[114]); MULADD(at[4], at[113]); MULADD(at[5], at[112]); MULADD(at[6], at[111]); MULADD(at[7], at[110]); MULADD(at[8], at[109]); MULADD(at[9], at[108]); MULADD(at[10], at[107]); MULADD(at[11], at[106]); MULADD(at[12], at[105]); MULADD(at[13], at[104]); MULADD(at[14], at[103]); MULADD(at[15], at[102]); MULADD(at[16], at[101]); MULADD(at[17], at[100]); MULADD(at[18], at[99]); MULADD(at[19], at[98]); MULADD(at[20], at[97]); MULADD(at[21], at[96]); MULADD(at[22], at[95]); MULADD(at[23], at[94]); MULADD(at[24], at[93]); MULADD(at[25], at[92]); MULADD(at[26], at[91]); MULADD(at[27], at[90]); MULADD(at[28], at[89]); MULADD(at[29], at[88]); MULADD(at[30], at[87]); MULADD(at[31], at[86]); MULADD(at[32], at[85]); MULADD(at[33], at[84]); MULADD(at[34], at[83]); MULADD(at[35], at[82]); MULADD(at[36], at[81]); MULADD(at[37], at[80]); MULADD(at[38], at[79]); MULADD(at[39], at[78]); MULADD(at[40], at[77]); MULADD(at[41], at[76]); MULADD(at[42], at[75]); MULADD(at[43], at[74]); MULADD(at[44], at[73]); MULADD(at[45], at[72]); MULADD(at[46], at[71]); MULADD(at[47], at[70]); MULADD(at[48], at[69]); MULADD(at[49], at[68]); MULADD(at[50], at[67]); MULADD(at[51], at[66]); MULADD(at[52], at[65]); MULADD(at[53], at[64]); + COMBA_STORE(C->dp[53]); + /* 54 */ + COMBA_FORWARD; + MULADD(at[0], at[118]); MULADD(at[1], at[117]); MULADD(at[2], at[116]); MULADD(at[3], at[115]); MULADD(at[4], at[114]); MULADD(at[5], at[113]); MULADD(at[6], at[112]); MULADD(at[7], at[111]); MULADD(at[8], at[110]); MULADD(at[9], at[109]); MULADD(at[10], at[108]); MULADD(at[11], at[107]); MULADD(at[12], at[106]); MULADD(at[13], at[105]); MULADD(at[14], at[104]); MULADD(at[15], at[103]); MULADD(at[16], at[102]); MULADD(at[17], at[101]); MULADD(at[18], at[100]); MULADD(at[19], at[99]); MULADD(at[20], at[98]); MULADD(at[21], at[97]); MULADD(at[22], at[96]); MULADD(at[23], at[95]); MULADD(at[24], at[94]); MULADD(at[25], at[93]); MULADD(at[26], at[92]); MULADD(at[27], at[91]); MULADD(at[28], at[90]); MULADD(at[29], at[89]); MULADD(at[30], at[88]); MULADD(at[31], at[87]); MULADD(at[32], at[86]); MULADD(at[33], at[85]); MULADD(at[34], at[84]); MULADD(at[35], at[83]); MULADD(at[36], at[82]); MULADD(at[37], at[81]); MULADD(at[38], at[80]); MULADD(at[39], at[79]); MULADD(at[40], at[78]); MULADD(at[41], at[77]); MULADD(at[42], at[76]); MULADD(at[43], at[75]); MULADD(at[44], at[74]); MULADD(at[45], at[73]); MULADD(at[46], at[72]); MULADD(at[47], at[71]); MULADD(at[48], at[70]); MULADD(at[49], at[69]); MULADD(at[50], at[68]); MULADD(at[51], at[67]); MULADD(at[52], at[66]); MULADD(at[53], at[65]); MULADD(at[54], at[64]); + COMBA_STORE(C->dp[54]); + /* 55 */ + COMBA_FORWARD; + MULADD(at[0], at[119]); MULADD(at[1], at[118]); MULADD(at[2], at[117]); MULADD(at[3], at[116]); MULADD(at[4], at[115]); MULADD(at[5], at[114]); MULADD(at[6], at[113]); MULADD(at[7], at[112]); MULADD(at[8], at[111]); MULADD(at[9], at[110]); MULADD(at[10], at[109]); MULADD(at[11], at[108]); MULADD(at[12], at[107]); MULADD(at[13], at[106]); MULADD(at[14], at[105]); MULADD(at[15], at[104]); MULADD(at[16], at[103]); MULADD(at[17], at[102]); MULADD(at[18], at[101]); MULADD(at[19], at[100]); MULADD(at[20], at[99]); MULADD(at[21], at[98]); MULADD(at[22], at[97]); MULADD(at[23], at[96]); MULADD(at[24], at[95]); MULADD(at[25], at[94]); MULADD(at[26], at[93]); MULADD(at[27], at[92]); MULADD(at[28], at[91]); MULADD(at[29], at[90]); MULADD(at[30], at[89]); MULADD(at[31], at[88]); MULADD(at[32], at[87]); MULADD(at[33], at[86]); MULADD(at[34], at[85]); MULADD(at[35], at[84]); MULADD(at[36], at[83]); MULADD(at[37], at[82]); MULADD(at[38], at[81]); MULADD(at[39], at[80]); MULADD(at[40], at[79]); MULADD(at[41], at[78]); MULADD(at[42], at[77]); MULADD(at[43], at[76]); MULADD(at[44], at[75]); MULADD(at[45], at[74]); MULADD(at[46], at[73]); MULADD(at[47], at[72]); MULADD(at[48], at[71]); MULADD(at[49], at[70]); MULADD(at[50], at[69]); MULADD(at[51], at[68]); MULADD(at[52], at[67]); MULADD(at[53], at[66]); MULADD(at[54], at[65]); MULADD(at[55], at[64]); + COMBA_STORE(C->dp[55]); + /* 56 */ + COMBA_FORWARD; + MULADD(at[0], at[120]); MULADD(at[1], at[119]); MULADD(at[2], at[118]); MULADD(at[3], at[117]); MULADD(at[4], at[116]); MULADD(at[5], at[115]); MULADD(at[6], at[114]); MULADD(at[7], at[113]); MULADD(at[8], at[112]); MULADD(at[9], at[111]); MULADD(at[10], at[110]); MULADD(at[11], at[109]); MULADD(at[12], at[108]); MULADD(at[13], at[107]); MULADD(at[14], at[106]); MULADD(at[15], at[105]); MULADD(at[16], at[104]); MULADD(at[17], at[103]); MULADD(at[18], at[102]); MULADD(at[19], at[101]); MULADD(at[20], at[100]); MULADD(at[21], at[99]); MULADD(at[22], at[98]); MULADD(at[23], at[97]); MULADD(at[24], at[96]); MULADD(at[25], at[95]); MULADD(at[26], at[94]); MULADD(at[27], at[93]); MULADD(at[28], at[92]); MULADD(at[29], at[91]); MULADD(at[30], at[90]); MULADD(at[31], at[89]); MULADD(at[32], at[88]); MULADD(at[33], at[87]); MULADD(at[34], at[86]); MULADD(at[35], at[85]); MULADD(at[36], at[84]); MULADD(at[37], at[83]); MULADD(at[38], at[82]); MULADD(at[39], at[81]); MULADD(at[40], at[80]); MULADD(at[41], at[79]); MULADD(at[42], at[78]); MULADD(at[43], at[77]); MULADD(at[44], at[76]); MULADD(at[45], at[75]); MULADD(at[46], at[74]); MULADD(at[47], at[73]); MULADD(at[48], at[72]); MULADD(at[49], at[71]); MULADD(at[50], at[70]); MULADD(at[51], at[69]); MULADD(at[52], at[68]); MULADD(at[53], at[67]); MULADD(at[54], at[66]); MULADD(at[55], at[65]); MULADD(at[56], at[64]); + COMBA_STORE(C->dp[56]); + /* 57 */ + COMBA_FORWARD; + MULADD(at[0], at[121]); MULADD(at[1], at[120]); MULADD(at[2], at[119]); MULADD(at[3], at[118]); MULADD(at[4], at[117]); MULADD(at[5], at[116]); MULADD(at[6], at[115]); MULADD(at[7], at[114]); MULADD(at[8], at[113]); MULADD(at[9], at[112]); MULADD(at[10], at[111]); MULADD(at[11], at[110]); MULADD(at[12], at[109]); MULADD(at[13], at[108]); MULADD(at[14], at[107]); MULADD(at[15], at[106]); MULADD(at[16], at[105]); MULADD(at[17], at[104]); MULADD(at[18], at[103]); MULADD(at[19], at[102]); MULADD(at[20], at[101]); MULADD(at[21], at[100]); MULADD(at[22], at[99]); MULADD(at[23], at[98]); MULADD(at[24], at[97]); MULADD(at[25], at[96]); MULADD(at[26], at[95]); MULADD(at[27], at[94]); MULADD(at[28], at[93]); MULADD(at[29], at[92]); MULADD(at[30], at[91]); MULADD(at[31], at[90]); MULADD(at[32], at[89]); MULADD(at[33], at[88]); MULADD(at[34], at[87]); MULADD(at[35], at[86]); MULADD(at[36], at[85]); MULADD(at[37], at[84]); MULADD(at[38], at[83]); MULADD(at[39], at[82]); MULADD(at[40], at[81]); MULADD(at[41], at[80]); MULADD(at[42], at[79]); MULADD(at[43], at[78]); MULADD(at[44], at[77]); MULADD(at[45], at[76]); MULADD(at[46], at[75]); MULADD(at[47], at[74]); MULADD(at[48], at[73]); MULADD(at[49], at[72]); MULADD(at[50], at[71]); MULADD(at[51], at[70]); MULADD(at[52], at[69]); MULADD(at[53], at[68]); MULADD(at[54], at[67]); MULADD(at[55], at[66]); MULADD(at[56], at[65]); MULADD(at[57], at[64]); + COMBA_STORE(C->dp[57]); + /* 58 */ + COMBA_FORWARD; + MULADD(at[0], at[122]); MULADD(at[1], at[121]); MULADD(at[2], at[120]); MULADD(at[3], at[119]); MULADD(at[4], at[118]); MULADD(at[5], at[117]); MULADD(at[6], at[116]); MULADD(at[7], at[115]); MULADD(at[8], at[114]); MULADD(at[9], at[113]); MULADD(at[10], at[112]); MULADD(at[11], at[111]); MULADD(at[12], at[110]); MULADD(at[13], at[109]); MULADD(at[14], at[108]); MULADD(at[15], at[107]); MULADD(at[16], at[106]); MULADD(at[17], at[105]); MULADD(at[18], at[104]); MULADD(at[19], at[103]); MULADD(at[20], at[102]); MULADD(at[21], at[101]); MULADD(at[22], at[100]); MULADD(at[23], at[99]); MULADD(at[24], at[98]); MULADD(at[25], at[97]); MULADD(at[26], at[96]); MULADD(at[27], at[95]); MULADD(at[28], at[94]); MULADD(at[29], at[93]); MULADD(at[30], at[92]); MULADD(at[31], at[91]); MULADD(at[32], at[90]); MULADD(at[33], at[89]); MULADD(at[34], at[88]); MULADD(at[35], at[87]); MULADD(at[36], at[86]); MULADD(at[37], at[85]); MULADD(at[38], at[84]); MULADD(at[39], at[83]); MULADD(at[40], at[82]); MULADD(at[41], at[81]); MULADD(at[42], at[80]); MULADD(at[43], at[79]); MULADD(at[44], at[78]); MULADD(at[45], at[77]); MULADD(at[46], at[76]); MULADD(at[47], at[75]); MULADD(at[48], at[74]); MULADD(at[49], at[73]); MULADD(at[50], at[72]); MULADD(at[51], at[71]); MULADD(at[52], at[70]); MULADD(at[53], at[69]); MULADD(at[54], at[68]); MULADD(at[55], at[67]); MULADD(at[56], at[66]); MULADD(at[57], at[65]); MULADD(at[58], at[64]); + COMBA_STORE(C->dp[58]); + /* 59 */ + COMBA_FORWARD; + MULADD(at[0], at[123]); MULADD(at[1], at[122]); MULADD(at[2], at[121]); MULADD(at[3], at[120]); MULADD(at[4], at[119]); MULADD(at[5], at[118]); MULADD(at[6], at[117]); MULADD(at[7], at[116]); MULADD(at[8], at[115]); MULADD(at[9], at[114]); MULADD(at[10], at[113]); MULADD(at[11], at[112]); MULADD(at[12], at[111]); MULADD(at[13], at[110]); MULADD(at[14], at[109]); MULADD(at[15], at[108]); MULADD(at[16], at[107]); MULADD(at[17], at[106]); MULADD(at[18], at[105]); MULADD(at[19], at[104]); MULADD(at[20], at[103]); MULADD(at[21], at[102]); MULADD(at[22], at[101]); MULADD(at[23], at[100]); MULADD(at[24], at[99]); MULADD(at[25], at[98]); MULADD(at[26], at[97]); MULADD(at[27], at[96]); MULADD(at[28], at[95]); MULADD(at[29], at[94]); MULADD(at[30], at[93]); MULADD(at[31], at[92]); MULADD(at[32], at[91]); MULADD(at[33], at[90]); MULADD(at[34], at[89]); MULADD(at[35], at[88]); MULADD(at[36], at[87]); MULADD(at[37], at[86]); MULADD(at[38], at[85]); MULADD(at[39], at[84]); MULADD(at[40], at[83]); MULADD(at[41], at[82]); MULADD(at[42], at[81]); MULADD(at[43], at[80]); MULADD(at[44], at[79]); MULADD(at[45], at[78]); MULADD(at[46], at[77]); MULADD(at[47], at[76]); MULADD(at[48], at[75]); MULADD(at[49], at[74]); MULADD(at[50], at[73]); MULADD(at[51], at[72]); MULADD(at[52], at[71]); MULADD(at[53], at[70]); MULADD(at[54], at[69]); MULADD(at[55], at[68]); MULADD(at[56], at[67]); MULADD(at[57], at[66]); MULADD(at[58], at[65]); MULADD(at[59], at[64]); + COMBA_STORE(C->dp[59]); + /* 60 */ + COMBA_FORWARD; + MULADD(at[0], at[124]); MULADD(at[1], at[123]); MULADD(at[2], at[122]); MULADD(at[3], at[121]); MULADD(at[4], at[120]); MULADD(at[5], at[119]); MULADD(at[6], at[118]); MULADD(at[7], at[117]); MULADD(at[8], at[116]); MULADD(at[9], at[115]); MULADD(at[10], at[114]); MULADD(at[11], at[113]); MULADD(at[12], at[112]); MULADD(at[13], at[111]); MULADD(at[14], at[110]); MULADD(at[15], at[109]); MULADD(at[16], at[108]); MULADD(at[17], at[107]); MULADD(at[18], at[106]); MULADD(at[19], at[105]); MULADD(at[20], at[104]); MULADD(at[21], at[103]); MULADD(at[22], at[102]); MULADD(at[23], at[101]); MULADD(at[24], at[100]); MULADD(at[25], at[99]); MULADD(at[26], at[98]); MULADD(at[27], at[97]); MULADD(at[28], at[96]); MULADD(at[29], at[95]); MULADD(at[30], at[94]); MULADD(at[31], at[93]); MULADD(at[32], at[92]); MULADD(at[33], at[91]); MULADD(at[34], at[90]); MULADD(at[35], at[89]); MULADD(at[36], at[88]); MULADD(at[37], at[87]); MULADD(at[38], at[86]); MULADD(at[39], at[85]); MULADD(at[40], at[84]); MULADD(at[41], at[83]); MULADD(at[42], at[82]); MULADD(at[43], at[81]); MULADD(at[44], at[80]); MULADD(at[45], at[79]); MULADD(at[46], at[78]); MULADD(at[47], at[77]); MULADD(at[48], at[76]); MULADD(at[49], at[75]); MULADD(at[50], at[74]); MULADD(at[51], at[73]); MULADD(at[52], at[72]); MULADD(at[53], at[71]); MULADD(at[54], at[70]); MULADD(at[55], at[69]); MULADD(at[56], at[68]); MULADD(at[57], at[67]); MULADD(at[58], at[66]); MULADD(at[59], at[65]); MULADD(at[60], at[64]); + COMBA_STORE(C->dp[60]); + /* 61 */ + COMBA_FORWARD; + MULADD(at[0], at[125]); MULADD(at[1], at[124]); MULADD(at[2], at[123]); MULADD(at[3], at[122]); MULADD(at[4], at[121]); MULADD(at[5], at[120]); MULADD(at[6], at[119]); MULADD(at[7], at[118]); MULADD(at[8], at[117]); MULADD(at[9], at[116]); MULADD(at[10], at[115]); MULADD(at[11], at[114]); MULADD(at[12], at[113]); MULADD(at[13], at[112]); MULADD(at[14], at[111]); MULADD(at[15], at[110]); MULADD(at[16], at[109]); MULADD(at[17], at[108]); MULADD(at[18], at[107]); MULADD(at[19], at[106]); MULADD(at[20], at[105]); MULADD(at[21], at[104]); MULADD(at[22], at[103]); MULADD(at[23], at[102]); MULADD(at[24], at[101]); MULADD(at[25], at[100]); MULADD(at[26], at[99]); MULADD(at[27], at[98]); MULADD(at[28], at[97]); MULADD(at[29], at[96]); MULADD(at[30], at[95]); MULADD(at[31], at[94]); MULADD(at[32], at[93]); MULADD(at[33], at[92]); MULADD(at[34], at[91]); MULADD(at[35], at[90]); MULADD(at[36], at[89]); MULADD(at[37], at[88]); MULADD(at[38], at[87]); MULADD(at[39], at[86]); MULADD(at[40], at[85]); MULADD(at[41], at[84]); MULADD(at[42], at[83]); MULADD(at[43], at[82]); MULADD(at[44], at[81]); MULADD(at[45], at[80]); MULADD(at[46], at[79]); MULADD(at[47], at[78]); MULADD(at[48], at[77]); MULADD(at[49], at[76]); MULADD(at[50], at[75]); MULADD(at[51], at[74]); MULADD(at[52], at[73]); MULADD(at[53], at[72]); MULADD(at[54], at[71]); MULADD(at[55], at[70]); MULADD(at[56], at[69]); MULADD(at[57], at[68]); MULADD(at[58], at[67]); MULADD(at[59], at[66]); MULADD(at[60], at[65]); MULADD(at[61], at[64]); + COMBA_STORE(C->dp[61]); + /* 62 */ + COMBA_FORWARD; + MULADD(at[0], at[126]); MULADD(at[1], at[125]); MULADD(at[2], at[124]); MULADD(at[3], at[123]); MULADD(at[4], at[122]); MULADD(at[5], at[121]); MULADD(at[6], at[120]); MULADD(at[7], at[119]); MULADD(at[8], at[118]); MULADD(at[9], at[117]); MULADD(at[10], at[116]); MULADD(at[11], at[115]); MULADD(at[12], at[114]); MULADD(at[13], at[113]); MULADD(at[14], at[112]); MULADD(at[15], at[111]); MULADD(at[16], at[110]); MULADD(at[17], at[109]); MULADD(at[18], at[108]); MULADD(at[19], at[107]); MULADD(at[20], at[106]); MULADD(at[21], at[105]); MULADD(at[22], at[104]); MULADD(at[23], at[103]); MULADD(at[24], at[102]); MULADD(at[25], at[101]); MULADD(at[26], at[100]); MULADD(at[27], at[99]); MULADD(at[28], at[98]); MULADD(at[29], at[97]); MULADD(at[30], at[96]); MULADD(at[31], at[95]); MULADD(at[32], at[94]); MULADD(at[33], at[93]); MULADD(at[34], at[92]); MULADD(at[35], at[91]); MULADD(at[36], at[90]); MULADD(at[37], at[89]); MULADD(at[38], at[88]); MULADD(at[39], at[87]); MULADD(at[40], at[86]); MULADD(at[41], at[85]); MULADD(at[42], at[84]); MULADD(at[43], at[83]); MULADD(at[44], at[82]); MULADD(at[45], at[81]); MULADD(at[46], at[80]); MULADD(at[47], at[79]); MULADD(at[48], at[78]); MULADD(at[49], at[77]); MULADD(at[50], at[76]); MULADD(at[51], at[75]); MULADD(at[52], at[74]); MULADD(at[53], at[73]); MULADD(at[54], at[72]); MULADD(at[55], at[71]); MULADD(at[56], at[70]); MULADD(at[57], at[69]); MULADD(at[58], at[68]); MULADD(at[59], at[67]); MULADD(at[60], at[66]); MULADD(at[61], at[65]); MULADD(at[62], at[64]); + COMBA_STORE(C->dp[62]); + /* 63 */ + COMBA_FORWARD; + MULADD(at[0], at[127]); MULADD(at[1], at[126]); MULADD(at[2], at[125]); MULADD(at[3], at[124]); MULADD(at[4], at[123]); MULADD(at[5], at[122]); MULADD(at[6], at[121]); MULADD(at[7], at[120]); MULADD(at[8], at[119]); MULADD(at[9], at[118]); MULADD(at[10], at[117]); MULADD(at[11], at[116]); MULADD(at[12], at[115]); MULADD(at[13], at[114]); MULADD(at[14], at[113]); MULADD(at[15], at[112]); MULADD(at[16], at[111]); MULADD(at[17], at[110]); MULADD(at[18], at[109]); MULADD(at[19], at[108]); MULADD(at[20], at[107]); MULADD(at[21], at[106]); MULADD(at[22], at[105]); MULADD(at[23], at[104]); MULADD(at[24], at[103]); MULADD(at[25], at[102]); MULADD(at[26], at[101]); MULADD(at[27], at[100]); MULADD(at[28], at[99]); MULADD(at[29], at[98]); MULADD(at[30], at[97]); MULADD(at[31], at[96]); MULADD(at[32], at[95]); MULADD(at[33], at[94]); MULADD(at[34], at[93]); MULADD(at[35], at[92]); MULADD(at[36], at[91]); MULADD(at[37], at[90]); MULADD(at[38], at[89]); MULADD(at[39], at[88]); MULADD(at[40], at[87]); MULADD(at[41], at[86]); MULADD(at[42], at[85]); MULADD(at[43], at[84]); MULADD(at[44], at[83]); MULADD(at[45], at[82]); MULADD(at[46], at[81]); MULADD(at[47], at[80]); MULADD(at[48], at[79]); MULADD(at[49], at[78]); MULADD(at[50], at[77]); MULADD(at[51], at[76]); MULADD(at[52], at[75]); MULADD(at[53], at[74]); MULADD(at[54], at[73]); MULADD(at[55], at[72]); MULADD(at[56], at[71]); MULADD(at[57], at[70]); MULADD(at[58], at[69]); MULADD(at[59], at[68]); MULADD(at[60], at[67]); MULADD(at[61], at[66]); MULADD(at[62], at[65]); MULADD(at[63], at[64]); + COMBA_STORE(C->dp[63]); + /* 64 */ + COMBA_FORWARD; + MULADD(at[1], at[127]); MULADD(at[2], at[126]); MULADD(at[3], at[125]); MULADD(at[4], at[124]); MULADD(at[5], at[123]); MULADD(at[6], at[122]); MULADD(at[7], at[121]); MULADD(at[8], at[120]); MULADD(at[9], at[119]); MULADD(at[10], at[118]); MULADD(at[11], at[117]); MULADD(at[12], at[116]); MULADD(at[13], at[115]); MULADD(at[14], at[114]); MULADD(at[15], at[113]); MULADD(at[16], at[112]); MULADD(at[17], at[111]); MULADD(at[18], at[110]); MULADD(at[19], at[109]); MULADD(at[20], at[108]); MULADD(at[21], at[107]); MULADD(at[22], at[106]); MULADD(at[23], at[105]); MULADD(at[24], at[104]); MULADD(at[25], at[103]); MULADD(at[26], at[102]); MULADD(at[27], at[101]); MULADD(at[28], at[100]); MULADD(at[29], at[99]); MULADD(at[30], at[98]); MULADD(at[31], at[97]); MULADD(at[32], at[96]); MULADD(at[33], at[95]); MULADD(at[34], at[94]); MULADD(at[35], at[93]); MULADD(at[36], at[92]); MULADD(at[37], at[91]); MULADD(at[38], at[90]); MULADD(at[39], at[89]); MULADD(at[40], at[88]); MULADD(at[41], at[87]); MULADD(at[42], at[86]); MULADD(at[43], at[85]); MULADD(at[44], at[84]); MULADD(at[45], at[83]); MULADD(at[46], at[82]); MULADD(at[47], at[81]); MULADD(at[48], at[80]); MULADD(at[49], at[79]); MULADD(at[50], at[78]); MULADD(at[51], at[77]); MULADD(at[52], at[76]); MULADD(at[53], at[75]); MULADD(at[54], at[74]); MULADD(at[55], at[73]); MULADD(at[56], at[72]); MULADD(at[57], at[71]); MULADD(at[58], at[70]); MULADD(at[59], at[69]); MULADD(at[60], at[68]); MULADD(at[61], at[67]); MULADD(at[62], at[66]); MULADD(at[63], at[65]); + COMBA_STORE(C->dp[64]); + /* 65 */ + COMBA_FORWARD; + MULADD(at[2], at[127]); MULADD(at[3], at[126]); MULADD(at[4], at[125]); MULADD(at[5], at[124]); MULADD(at[6], at[123]); MULADD(at[7], at[122]); MULADD(at[8], at[121]); MULADD(at[9], at[120]); MULADD(at[10], at[119]); MULADD(at[11], at[118]); MULADD(at[12], at[117]); MULADD(at[13], at[116]); MULADD(at[14], at[115]); MULADD(at[15], at[114]); MULADD(at[16], at[113]); MULADD(at[17], at[112]); MULADD(at[18], at[111]); MULADD(at[19], at[110]); MULADD(at[20], at[109]); MULADD(at[21], at[108]); MULADD(at[22], at[107]); MULADD(at[23], at[106]); MULADD(at[24], at[105]); MULADD(at[25], at[104]); MULADD(at[26], at[103]); MULADD(at[27], at[102]); MULADD(at[28], at[101]); MULADD(at[29], at[100]); MULADD(at[30], at[99]); MULADD(at[31], at[98]); MULADD(at[32], at[97]); MULADD(at[33], at[96]); MULADD(at[34], at[95]); MULADD(at[35], at[94]); MULADD(at[36], at[93]); MULADD(at[37], at[92]); MULADD(at[38], at[91]); MULADD(at[39], at[90]); MULADD(at[40], at[89]); MULADD(at[41], at[88]); MULADD(at[42], at[87]); MULADD(at[43], at[86]); MULADD(at[44], at[85]); MULADD(at[45], at[84]); MULADD(at[46], at[83]); MULADD(at[47], at[82]); MULADD(at[48], at[81]); MULADD(at[49], at[80]); MULADD(at[50], at[79]); MULADD(at[51], at[78]); MULADD(at[52], at[77]); MULADD(at[53], at[76]); MULADD(at[54], at[75]); MULADD(at[55], at[74]); MULADD(at[56], at[73]); MULADD(at[57], at[72]); MULADD(at[58], at[71]); MULADD(at[59], at[70]); MULADD(at[60], at[69]); MULADD(at[61], at[68]); MULADD(at[62], at[67]); MULADD(at[63], at[66]); + COMBA_STORE(C->dp[65]); + /* 66 */ + COMBA_FORWARD; + MULADD(at[3], at[127]); MULADD(at[4], at[126]); MULADD(at[5], at[125]); MULADD(at[6], at[124]); MULADD(at[7], at[123]); MULADD(at[8], at[122]); MULADD(at[9], at[121]); MULADD(at[10], at[120]); MULADD(at[11], at[119]); MULADD(at[12], at[118]); MULADD(at[13], at[117]); MULADD(at[14], at[116]); MULADD(at[15], at[115]); MULADD(at[16], at[114]); MULADD(at[17], at[113]); MULADD(at[18], at[112]); MULADD(at[19], at[111]); MULADD(at[20], at[110]); MULADD(at[21], at[109]); MULADD(at[22], at[108]); MULADD(at[23], at[107]); MULADD(at[24], at[106]); MULADD(at[25], at[105]); MULADD(at[26], at[104]); MULADD(at[27], at[103]); MULADD(at[28], at[102]); MULADD(at[29], at[101]); MULADD(at[30], at[100]); MULADD(at[31], at[99]); MULADD(at[32], at[98]); MULADD(at[33], at[97]); MULADD(at[34], at[96]); MULADD(at[35], at[95]); MULADD(at[36], at[94]); MULADD(at[37], at[93]); MULADD(at[38], at[92]); MULADD(at[39], at[91]); MULADD(at[40], at[90]); MULADD(at[41], at[89]); MULADD(at[42], at[88]); MULADD(at[43], at[87]); MULADD(at[44], at[86]); MULADD(at[45], at[85]); MULADD(at[46], at[84]); MULADD(at[47], at[83]); MULADD(at[48], at[82]); MULADD(at[49], at[81]); MULADD(at[50], at[80]); MULADD(at[51], at[79]); MULADD(at[52], at[78]); MULADD(at[53], at[77]); MULADD(at[54], at[76]); MULADD(at[55], at[75]); MULADD(at[56], at[74]); MULADD(at[57], at[73]); MULADD(at[58], at[72]); MULADD(at[59], at[71]); MULADD(at[60], at[70]); MULADD(at[61], at[69]); MULADD(at[62], at[68]); MULADD(at[63], at[67]); + COMBA_STORE(C->dp[66]); + /* 67 */ + COMBA_FORWARD; + MULADD(at[4], at[127]); MULADD(at[5], at[126]); MULADD(at[6], at[125]); MULADD(at[7], at[124]); MULADD(at[8], at[123]); MULADD(at[9], at[122]); MULADD(at[10], at[121]); MULADD(at[11], at[120]); MULADD(at[12], at[119]); MULADD(at[13], at[118]); MULADD(at[14], at[117]); MULADD(at[15], at[116]); MULADD(at[16], at[115]); MULADD(at[17], at[114]); MULADD(at[18], at[113]); MULADD(at[19], at[112]); MULADD(at[20], at[111]); MULADD(at[21], at[110]); MULADD(at[22], at[109]); MULADD(at[23], at[108]); MULADD(at[24], at[107]); MULADD(at[25], at[106]); MULADD(at[26], at[105]); MULADD(at[27], at[104]); MULADD(at[28], at[103]); MULADD(at[29], at[102]); MULADD(at[30], at[101]); MULADD(at[31], at[100]); MULADD(at[32], at[99]); MULADD(at[33], at[98]); MULADD(at[34], at[97]); MULADD(at[35], at[96]); MULADD(at[36], at[95]); MULADD(at[37], at[94]); MULADD(at[38], at[93]); MULADD(at[39], at[92]); MULADD(at[40], at[91]); MULADD(at[41], at[90]); MULADD(at[42], at[89]); MULADD(at[43], at[88]); MULADD(at[44], at[87]); MULADD(at[45], at[86]); MULADD(at[46], at[85]); MULADD(at[47], at[84]); MULADD(at[48], at[83]); MULADD(at[49], at[82]); MULADD(at[50], at[81]); MULADD(at[51], at[80]); MULADD(at[52], at[79]); MULADD(at[53], at[78]); MULADD(at[54], at[77]); MULADD(at[55], at[76]); MULADD(at[56], at[75]); MULADD(at[57], at[74]); MULADD(at[58], at[73]); MULADD(at[59], at[72]); MULADD(at[60], at[71]); MULADD(at[61], at[70]); MULADD(at[62], at[69]); MULADD(at[63], at[68]); + COMBA_STORE(C->dp[67]); + /* 68 */ + COMBA_FORWARD; + MULADD(at[5], at[127]); MULADD(at[6], at[126]); MULADD(at[7], at[125]); MULADD(at[8], at[124]); MULADD(at[9], at[123]); MULADD(at[10], at[122]); MULADD(at[11], at[121]); MULADD(at[12], at[120]); MULADD(at[13], at[119]); MULADD(at[14], at[118]); MULADD(at[15], at[117]); MULADD(at[16], at[116]); MULADD(at[17], at[115]); MULADD(at[18], at[114]); MULADD(at[19], at[113]); MULADD(at[20], at[112]); MULADD(at[21], at[111]); MULADD(at[22], at[110]); MULADD(at[23], at[109]); MULADD(at[24], at[108]); MULADD(at[25], at[107]); MULADD(at[26], at[106]); MULADD(at[27], at[105]); MULADD(at[28], at[104]); MULADD(at[29], at[103]); MULADD(at[30], at[102]); MULADD(at[31], at[101]); MULADD(at[32], at[100]); MULADD(at[33], at[99]); MULADD(at[34], at[98]); MULADD(at[35], at[97]); MULADD(at[36], at[96]); MULADD(at[37], at[95]); MULADD(at[38], at[94]); MULADD(at[39], at[93]); MULADD(at[40], at[92]); MULADD(at[41], at[91]); MULADD(at[42], at[90]); MULADD(at[43], at[89]); MULADD(at[44], at[88]); MULADD(at[45], at[87]); MULADD(at[46], at[86]); MULADD(at[47], at[85]); MULADD(at[48], at[84]); MULADD(at[49], at[83]); MULADD(at[50], at[82]); MULADD(at[51], at[81]); MULADD(at[52], at[80]); MULADD(at[53], at[79]); MULADD(at[54], at[78]); MULADD(at[55], at[77]); MULADD(at[56], at[76]); MULADD(at[57], at[75]); MULADD(at[58], at[74]); MULADD(at[59], at[73]); MULADD(at[60], at[72]); MULADD(at[61], at[71]); MULADD(at[62], at[70]); MULADD(at[63], at[69]); + COMBA_STORE(C->dp[68]); + /* 69 */ + COMBA_FORWARD; + MULADD(at[6], at[127]); MULADD(at[7], at[126]); MULADD(at[8], at[125]); MULADD(at[9], at[124]); MULADD(at[10], at[123]); MULADD(at[11], at[122]); MULADD(at[12], at[121]); MULADD(at[13], at[120]); MULADD(at[14], at[119]); MULADD(at[15], at[118]); MULADD(at[16], at[117]); MULADD(at[17], at[116]); MULADD(at[18], at[115]); MULADD(at[19], at[114]); MULADD(at[20], at[113]); MULADD(at[21], at[112]); MULADD(at[22], at[111]); MULADD(at[23], at[110]); MULADD(at[24], at[109]); MULADD(at[25], at[108]); MULADD(at[26], at[107]); MULADD(at[27], at[106]); MULADD(at[28], at[105]); MULADD(at[29], at[104]); MULADD(at[30], at[103]); MULADD(at[31], at[102]); MULADD(at[32], at[101]); MULADD(at[33], at[100]); MULADD(at[34], at[99]); MULADD(at[35], at[98]); MULADD(at[36], at[97]); MULADD(at[37], at[96]); MULADD(at[38], at[95]); MULADD(at[39], at[94]); MULADD(at[40], at[93]); MULADD(at[41], at[92]); MULADD(at[42], at[91]); MULADD(at[43], at[90]); MULADD(at[44], at[89]); MULADD(at[45], at[88]); MULADD(at[46], at[87]); MULADD(at[47], at[86]); MULADD(at[48], at[85]); MULADD(at[49], at[84]); MULADD(at[50], at[83]); MULADD(at[51], at[82]); MULADD(at[52], at[81]); MULADD(at[53], at[80]); MULADD(at[54], at[79]); MULADD(at[55], at[78]); MULADD(at[56], at[77]); MULADD(at[57], at[76]); MULADD(at[58], at[75]); MULADD(at[59], at[74]); MULADD(at[60], at[73]); MULADD(at[61], at[72]); MULADD(at[62], at[71]); MULADD(at[63], at[70]); + COMBA_STORE(C->dp[69]); + /* 70 */ + COMBA_FORWARD; + MULADD(at[7], at[127]); MULADD(at[8], at[126]); MULADD(at[9], at[125]); MULADD(at[10], at[124]); MULADD(at[11], at[123]); MULADD(at[12], at[122]); MULADD(at[13], at[121]); MULADD(at[14], at[120]); MULADD(at[15], at[119]); MULADD(at[16], at[118]); MULADD(at[17], at[117]); MULADD(at[18], at[116]); MULADD(at[19], at[115]); MULADD(at[20], at[114]); MULADD(at[21], at[113]); MULADD(at[22], at[112]); MULADD(at[23], at[111]); MULADD(at[24], at[110]); MULADD(at[25], at[109]); MULADD(at[26], at[108]); MULADD(at[27], at[107]); MULADD(at[28], at[106]); MULADD(at[29], at[105]); MULADD(at[30], at[104]); MULADD(at[31], at[103]); MULADD(at[32], at[102]); MULADD(at[33], at[101]); MULADD(at[34], at[100]); MULADD(at[35], at[99]); MULADD(at[36], at[98]); MULADD(at[37], at[97]); MULADD(at[38], at[96]); MULADD(at[39], at[95]); MULADD(at[40], at[94]); MULADD(at[41], at[93]); MULADD(at[42], at[92]); MULADD(at[43], at[91]); MULADD(at[44], at[90]); MULADD(at[45], at[89]); MULADD(at[46], at[88]); MULADD(at[47], at[87]); MULADD(at[48], at[86]); MULADD(at[49], at[85]); MULADD(at[50], at[84]); MULADD(at[51], at[83]); MULADD(at[52], at[82]); MULADD(at[53], at[81]); MULADD(at[54], at[80]); MULADD(at[55], at[79]); MULADD(at[56], at[78]); MULADD(at[57], at[77]); MULADD(at[58], at[76]); MULADD(at[59], at[75]); MULADD(at[60], at[74]); MULADD(at[61], at[73]); MULADD(at[62], at[72]); MULADD(at[63], at[71]); + COMBA_STORE(C->dp[70]); + /* 71 */ + COMBA_FORWARD; + MULADD(at[8], at[127]); MULADD(at[9], at[126]); MULADD(at[10], at[125]); MULADD(at[11], at[124]); MULADD(at[12], at[123]); MULADD(at[13], at[122]); MULADD(at[14], at[121]); MULADD(at[15], at[120]); MULADD(at[16], at[119]); MULADD(at[17], at[118]); MULADD(at[18], at[117]); MULADD(at[19], at[116]); MULADD(at[20], at[115]); MULADD(at[21], at[114]); MULADD(at[22], at[113]); MULADD(at[23], at[112]); MULADD(at[24], at[111]); MULADD(at[25], at[110]); MULADD(at[26], at[109]); MULADD(at[27], at[108]); MULADD(at[28], at[107]); MULADD(at[29], at[106]); MULADD(at[30], at[105]); MULADD(at[31], at[104]); MULADD(at[32], at[103]); MULADD(at[33], at[102]); MULADD(at[34], at[101]); MULADD(at[35], at[100]); MULADD(at[36], at[99]); MULADD(at[37], at[98]); MULADD(at[38], at[97]); MULADD(at[39], at[96]); MULADD(at[40], at[95]); MULADD(at[41], at[94]); MULADD(at[42], at[93]); MULADD(at[43], at[92]); MULADD(at[44], at[91]); MULADD(at[45], at[90]); MULADD(at[46], at[89]); MULADD(at[47], at[88]); MULADD(at[48], at[87]); MULADD(at[49], at[86]); MULADD(at[50], at[85]); MULADD(at[51], at[84]); MULADD(at[52], at[83]); MULADD(at[53], at[82]); MULADD(at[54], at[81]); MULADD(at[55], at[80]); MULADD(at[56], at[79]); MULADD(at[57], at[78]); MULADD(at[58], at[77]); MULADD(at[59], at[76]); MULADD(at[60], at[75]); MULADD(at[61], at[74]); MULADD(at[62], at[73]); MULADD(at[63], at[72]); + COMBA_STORE(C->dp[71]); + /* 72 */ + COMBA_FORWARD; + MULADD(at[9], at[127]); MULADD(at[10], at[126]); MULADD(at[11], at[125]); MULADD(at[12], at[124]); MULADD(at[13], at[123]); MULADD(at[14], at[122]); MULADD(at[15], at[121]); MULADD(at[16], at[120]); MULADD(at[17], at[119]); MULADD(at[18], at[118]); MULADD(at[19], at[117]); MULADD(at[20], at[116]); MULADD(at[21], at[115]); MULADD(at[22], at[114]); MULADD(at[23], at[113]); MULADD(at[24], at[112]); MULADD(at[25], at[111]); MULADD(at[26], at[110]); MULADD(at[27], at[109]); MULADD(at[28], at[108]); MULADD(at[29], at[107]); MULADD(at[30], at[106]); MULADD(at[31], at[105]); MULADD(at[32], at[104]); MULADD(at[33], at[103]); MULADD(at[34], at[102]); MULADD(at[35], at[101]); MULADD(at[36], at[100]); MULADD(at[37], at[99]); MULADD(at[38], at[98]); MULADD(at[39], at[97]); MULADD(at[40], at[96]); MULADD(at[41], at[95]); MULADD(at[42], at[94]); MULADD(at[43], at[93]); MULADD(at[44], at[92]); MULADD(at[45], at[91]); MULADD(at[46], at[90]); MULADD(at[47], at[89]); MULADD(at[48], at[88]); MULADD(at[49], at[87]); MULADD(at[50], at[86]); MULADD(at[51], at[85]); MULADD(at[52], at[84]); MULADD(at[53], at[83]); MULADD(at[54], at[82]); MULADD(at[55], at[81]); MULADD(at[56], at[80]); MULADD(at[57], at[79]); MULADD(at[58], at[78]); MULADD(at[59], at[77]); MULADD(at[60], at[76]); MULADD(at[61], at[75]); MULADD(at[62], at[74]); MULADD(at[63], at[73]); + COMBA_STORE(C->dp[72]); + /* 73 */ + COMBA_FORWARD; + MULADD(at[10], at[127]); MULADD(at[11], at[126]); MULADD(at[12], at[125]); MULADD(at[13], at[124]); MULADD(at[14], at[123]); MULADD(at[15], at[122]); MULADD(at[16], at[121]); MULADD(at[17], at[120]); MULADD(at[18], at[119]); MULADD(at[19], at[118]); MULADD(at[20], at[117]); MULADD(at[21], at[116]); MULADD(at[22], at[115]); MULADD(at[23], at[114]); MULADD(at[24], at[113]); MULADD(at[25], at[112]); MULADD(at[26], at[111]); MULADD(at[27], at[110]); MULADD(at[28], at[109]); MULADD(at[29], at[108]); MULADD(at[30], at[107]); MULADD(at[31], at[106]); MULADD(at[32], at[105]); MULADD(at[33], at[104]); MULADD(at[34], at[103]); MULADD(at[35], at[102]); MULADD(at[36], at[101]); MULADD(at[37], at[100]); MULADD(at[38], at[99]); MULADD(at[39], at[98]); MULADD(at[40], at[97]); MULADD(at[41], at[96]); MULADD(at[42], at[95]); MULADD(at[43], at[94]); MULADD(at[44], at[93]); MULADD(at[45], at[92]); MULADD(at[46], at[91]); MULADD(at[47], at[90]); MULADD(at[48], at[89]); MULADD(at[49], at[88]); MULADD(at[50], at[87]); MULADD(at[51], at[86]); MULADD(at[52], at[85]); MULADD(at[53], at[84]); MULADD(at[54], at[83]); MULADD(at[55], at[82]); MULADD(at[56], at[81]); MULADD(at[57], at[80]); MULADD(at[58], at[79]); MULADD(at[59], at[78]); MULADD(at[60], at[77]); MULADD(at[61], at[76]); MULADD(at[62], at[75]); MULADD(at[63], at[74]); + COMBA_STORE(C->dp[73]); + /* 74 */ + COMBA_FORWARD; + MULADD(at[11], at[127]); MULADD(at[12], at[126]); MULADD(at[13], at[125]); MULADD(at[14], at[124]); MULADD(at[15], at[123]); MULADD(at[16], at[122]); MULADD(at[17], at[121]); MULADD(at[18], at[120]); MULADD(at[19], at[119]); MULADD(at[20], at[118]); MULADD(at[21], at[117]); MULADD(at[22], at[116]); MULADD(at[23], at[115]); MULADD(at[24], at[114]); MULADD(at[25], at[113]); MULADD(at[26], at[112]); MULADD(at[27], at[111]); MULADD(at[28], at[110]); MULADD(at[29], at[109]); MULADD(at[30], at[108]); MULADD(at[31], at[107]); MULADD(at[32], at[106]); MULADD(at[33], at[105]); MULADD(at[34], at[104]); MULADD(at[35], at[103]); MULADD(at[36], at[102]); MULADD(at[37], at[101]); MULADD(at[38], at[100]); MULADD(at[39], at[99]); MULADD(at[40], at[98]); MULADD(at[41], at[97]); MULADD(at[42], at[96]); MULADD(at[43], at[95]); MULADD(at[44], at[94]); MULADD(at[45], at[93]); MULADD(at[46], at[92]); MULADD(at[47], at[91]); MULADD(at[48], at[90]); MULADD(at[49], at[89]); MULADD(at[50], at[88]); MULADD(at[51], at[87]); MULADD(at[52], at[86]); MULADD(at[53], at[85]); MULADD(at[54], at[84]); MULADD(at[55], at[83]); MULADD(at[56], at[82]); MULADD(at[57], at[81]); MULADD(at[58], at[80]); MULADD(at[59], at[79]); MULADD(at[60], at[78]); MULADD(at[61], at[77]); MULADD(at[62], at[76]); MULADD(at[63], at[75]); + COMBA_STORE(C->dp[74]); + /* 75 */ + COMBA_FORWARD; + MULADD(at[12], at[127]); MULADD(at[13], at[126]); MULADD(at[14], at[125]); MULADD(at[15], at[124]); MULADD(at[16], at[123]); MULADD(at[17], at[122]); MULADD(at[18], at[121]); MULADD(at[19], at[120]); MULADD(at[20], at[119]); MULADD(at[21], at[118]); MULADD(at[22], at[117]); MULADD(at[23], at[116]); MULADD(at[24], at[115]); MULADD(at[25], at[114]); MULADD(at[26], at[113]); MULADD(at[27], at[112]); MULADD(at[28], at[111]); MULADD(at[29], at[110]); MULADD(at[30], at[109]); MULADD(at[31], at[108]); MULADD(at[32], at[107]); MULADD(at[33], at[106]); MULADD(at[34], at[105]); MULADD(at[35], at[104]); MULADD(at[36], at[103]); MULADD(at[37], at[102]); MULADD(at[38], at[101]); MULADD(at[39], at[100]); MULADD(at[40], at[99]); MULADD(at[41], at[98]); MULADD(at[42], at[97]); MULADD(at[43], at[96]); MULADD(at[44], at[95]); MULADD(at[45], at[94]); MULADD(at[46], at[93]); MULADD(at[47], at[92]); MULADD(at[48], at[91]); MULADD(at[49], at[90]); MULADD(at[50], at[89]); MULADD(at[51], at[88]); MULADD(at[52], at[87]); MULADD(at[53], at[86]); MULADD(at[54], at[85]); MULADD(at[55], at[84]); MULADD(at[56], at[83]); MULADD(at[57], at[82]); MULADD(at[58], at[81]); MULADD(at[59], at[80]); MULADD(at[60], at[79]); MULADD(at[61], at[78]); MULADD(at[62], at[77]); MULADD(at[63], at[76]); + COMBA_STORE(C->dp[75]); + /* 76 */ + COMBA_FORWARD; + MULADD(at[13], at[127]); MULADD(at[14], at[126]); MULADD(at[15], at[125]); MULADD(at[16], at[124]); MULADD(at[17], at[123]); MULADD(at[18], at[122]); MULADD(at[19], at[121]); MULADD(at[20], at[120]); MULADD(at[21], at[119]); MULADD(at[22], at[118]); MULADD(at[23], at[117]); MULADD(at[24], at[116]); MULADD(at[25], at[115]); MULADD(at[26], at[114]); MULADD(at[27], at[113]); MULADD(at[28], at[112]); MULADD(at[29], at[111]); MULADD(at[30], at[110]); MULADD(at[31], at[109]); MULADD(at[32], at[108]); MULADD(at[33], at[107]); MULADD(at[34], at[106]); MULADD(at[35], at[105]); MULADD(at[36], at[104]); MULADD(at[37], at[103]); MULADD(at[38], at[102]); MULADD(at[39], at[101]); MULADD(at[40], at[100]); MULADD(at[41], at[99]); MULADD(at[42], at[98]); MULADD(at[43], at[97]); MULADD(at[44], at[96]); MULADD(at[45], at[95]); MULADD(at[46], at[94]); MULADD(at[47], at[93]); MULADD(at[48], at[92]); MULADD(at[49], at[91]); MULADD(at[50], at[90]); MULADD(at[51], at[89]); MULADD(at[52], at[88]); MULADD(at[53], at[87]); MULADD(at[54], at[86]); MULADD(at[55], at[85]); MULADD(at[56], at[84]); MULADD(at[57], at[83]); MULADD(at[58], at[82]); MULADD(at[59], at[81]); MULADD(at[60], at[80]); MULADD(at[61], at[79]); MULADD(at[62], at[78]); MULADD(at[63], at[77]); + COMBA_STORE(C->dp[76]); + /* 77 */ + COMBA_FORWARD; + MULADD(at[14], at[127]); MULADD(at[15], at[126]); MULADD(at[16], at[125]); MULADD(at[17], at[124]); MULADD(at[18], at[123]); MULADD(at[19], at[122]); MULADD(at[20], at[121]); MULADD(at[21], at[120]); MULADD(at[22], at[119]); MULADD(at[23], at[118]); MULADD(at[24], at[117]); MULADD(at[25], at[116]); MULADD(at[26], at[115]); MULADD(at[27], at[114]); MULADD(at[28], at[113]); MULADD(at[29], at[112]); MULADD(at[30], at[111]); MULADD(at[31], at[110]); MULADD(at[32], at[109]); MULADD(at[33], at[108]); MULADD(at[34], at[107]); MULADD(at[35], at[106]); MULADD(at[36], at[105]); MULADD(at[37], at[104]); MULADD(at[38], at[103]); MULADD(at[39], at[102]); MULADD(at[40], at[101]); MULADD(at[41], at[100]); MULADD(at[42], at[99]); MULADD(at[43], at[98]); MULADD(at[44], at[97]); MULADD(at[45], at[96]); MULADD(at[46], at[95]); MULADD(at[47], at[94]); MULADD(at[48], at[93]); MULADD(at[49], at[92]); MULADD(at[50], at[91]); MULADD(at[51], at[90]); MULADD(at[52], at[89]); MULADD(at[53], at[88]); MULADD(at[54], at[87]); MULADD(at[55], at[86]); MULADD(at[56], at[85]); MULADD(at[57], at[84]); MULADD(at[58], at[83]); MULADD(at[59], at[82]); MULADD(at[60], at[81]); MULADD(at[61], at[80]); MULADD(at[62], at[79]); MULADD(at[63], at[78]); + COMBA_STORE(C->dp[77]); + /* 78 */ + COMBA_FORWARD; + MULADD(at[15], at[127]); MULADD(at[16], at[126]); MULADD(at[17], at[125]); MULADD(at[18], at[124]); MULADD(at[19], at[123]); MULADD(at[20], at[122]); MULADD(at[21], at[121]); MULADD(at[22], at[120]); MULADD(at[23], at[119]); MULADD(at[24], at[118]); MULADD(at[25], at[117]); MULADD(at[26], at[116]); MULADD(at[27], at[115]); MULADD(at[28], at[114]); MULADD(at[29], at[113]); MULADD(at[30], at[112]); MULADD(at[31], at[111]); MULADD(at[32], at[110]); MULADD(at[33], at[109]); MULADD(at[34], at[108]); MULADD(at[35], at[107]); MULADD(at[36], at[106]); MULADD(at[37], at[105]); MULADD(at[38], at[104]); MULADD(at[39], at[103]); MULADD(at[40], at[102]); MULADD(at[41], at[101]); MULADD(at[42], at[100]); MULADD(at[43], at[99]); MULADD(at[44], at[98]); MULADD(at[45], at[97]); MULADD(at[46], at[96]); MULADD(at[47], at[95]); MULADD(at[48], at[94]); MULADD(at[49], at[93]); MULADD(at[50], at[92]); MULADD(at[51], at[91]); MULADD(at[52], at[90]); MULADD(at[53], at[89]); MULADD(at[54], at[88]); MULADD(at[55], at[87]); MULADD(at[56], at[86]); MULADD(at[57], at[85]); MULADD(at[58], at[84]); MULADD(at[59], at[83]); MULADD(at[60], at[82]); MULADD(at[61], at[81]); MULADD(at[62], at[80]); MULADD(at[63], at[79]); + COMBA_STORE(C->dp[78]); + /* 79 */ + COMBA_FORWARD; + MULADD(at[16], at[127]); MULADD(at[17], at[126]); MULADD(at[18], at[125]); MULADD(at[19], at[124]); MULADD(at[20], at[123]); MULADD(at[21], at[122]); MULADD(at[22], at[121]); MULADD(at[23], at[120]); MULADD(at[24], at[119]); MULADD(at[25], at[118]); MULADD(at[26], at[117]); MULADD(at[27], at[116]); MULADD(at[28], at[115]); MULADD(at[29], at[114]); MULADD(at[30], at[113]); MULADD(at[31], at[112]); MULADD(at[32], at[111]); MULADD(at[33], at[110]); MULADD(at[34], at[109]); MULADD(at[35], at[108]); MULADD(at[36], at[107]); MULADD(at[37], at[106]); MULADD(at[38], at[105]); MULADD(at[39], at[104]); MULADD(at[40], at[103]); MULADD(at[41], at[102]); MULADD(at[42], at[101]); MULADD(at[43], at[100]); MULADD(at[44], at[99]); MULADD(at[45], at[98]); MULADD(at[46], at[97]); MULADD(at[47], at[96]); MULADD(at[48], at[95]); MULADD(at[49], at[94]); MULADD(at[50], at[93]); MULADD(at[51], at[92]); MULADD(at[52], at[91]); MULADD(at[53], at[90]); MULADD(at[54], at[89]); MULADD(at[55], at[88]); MULADD(at[56], at[87]); MULADD(at[57], at[86]); MULADD(at[58], at[85]); MULADD(at[59], at[84]); MULADD(at[60], at[83]); MULADD(at[61], at[82]); MULADD(at[62], at[81]); MULADD(at[63], at[80]); + COMBA_STORE(C->dp[79]); + /* 80 */ + COMBA_FORWARD; + MULADD(at[17], at[127]); MULADD(at[18], at[126]); MULADD(at[19], at[125]); MULADD(at[20], at[124]); MULADD(at[21], at[123]); MULADD(at[22], at[122]); MULADD(at[23], at[121]); MULADD(at[24], at[120]); MULADD(at[25], at[119]); MULADD(at[26], at[118]); MULADD(at[27], at[117]); MULADD(at[28], at[116]); MULADD(at[29], at[115]); MULADD(at[30], at[114]); MULADD(at[31], at[113]); MULADD(at[32], at[112]); MULADD(at[33], at[111]); MULADD(at[34], at[110]); MULADD(at[35], at[109]); MULADD(at[36], at[108]); MULADD(at[37], at[107]); MULADD(at[38], at[106]); MULADD(at[39], at[105]); MULADD(at[40], at[104]); MULADD(at[41], at[103]); MULADD(at[42], at[102]); MULADD(at[43], at[101]); MULADD(at[44], at[100]); MULADD(at[45], at[99]); MULADD(at[46], at[98]); MULADD(at[47], at[97]); MULADD(at[48], at[96]); MULADD(at[49], at[95]); MULADD(at[50], at[94]); MULADD(at[51], at[93]); MULADD(at[52], at[92]); MULADD(at[53], at[91]); MULADD(at[54], at[90]); MULADD(at[55], at[89]); MULADD(at[56], at[88]); MULADD(at[57], at[87]); MULADD(at[58], at[86]); MULADD(at[59], at[85]); MULADD(at[60], at[84]); MULADD(at[61], at[83]); MULADD(at[62], at[82]); MULADD(at[63], at[81]); + COMBA_STORE(C->dp[80]); + /* 81 */ + COMBA_FORWARD; + MULADD(at[18], at[127]); MULADD(at[19], at[126]); MULADD(at[20], at[125]); MULADD(at[21], at[124]); MULADD(at[22], at[123]); MULADD(at[23], at[122]); MULADD(at[24], at[121]); MULADD(at[25], at[120]); MULADD(at[26], at[119]); MULADD(at[27], at[118]); MULADD(at[28], at[117]); MULADD(at[29], at[116]); MULADD(at[30], at[115]); MULADD(at[31], at[114]); MULADD(at[32], at[113]); MULADD(at[33], at[112]); MULADD(at[34], at[111]); MULADD(at[35], at[110]); MULADD(at[36], at[109]); MULADD(at[37], at[108]); MULADD(at[38], at[107]); MULADD(at[39], at[106]); MULADD(at[40], at[105]); MULADD(at[41], at[104]); MULADD(at[42], at[103]); MULADD(at[43], at[102]); MULADD(at[44], at[101]); MULADD(at[45], at[100]); MULADD(at[46], at[99]); MULADD(at[47], at[98]); MULADD(at[48], at[97]); MULADD(at[49], at[96]); MULADD(at[50], at[95]); MULADD(at[51], at[94]); MULADD(at[52], at[93]); MULADD(at[53], at[92]); MULADD(at[54], at[91]); MULADD(at[55], at[90]); MULADD(at[56], at[89]); MULADD(at[57], at[88]); MULADD(at[58], at[87]); MULADD(at[59], at[86]); MULADD(at[60], at[85]); MULADD(at[61], at[84]); MULADD(at[62], at[83]); MULADD(at[63], at[82]); + COMBA_STORE(C->dp[81]); + /* 82 */ + COMBA_FORWARD; + MULADD(at[19], at[127]); MULADD(at[20], at[126]); MULADD(at[21], at[125]); MULADD(at[22], at[124]); MULADD(at[23], at[123]); MULADD(at[24], at[122]); MULADD(at[25], at[121]); MULADD(at[26], at[120]); MULADD(at[27], at[119]); MULADD(at[28], at[118]); MULADD(at[29], at[117]); MULADD(at[30], at[116]); MULADD(at[31], at[115]); MULADD(at[32], at[114]); MULADD(at[33], at[113]); MULADD(at[34], at[112]); MULADD(at[35], at[111]); MULADD(at[36], at[110]); MULADD(at[37], at[109]); MULADD(at[38], at[108]); MULADD(at[39], at[107]); MULADD(at[40], at[106]); MULADD(at[41], at[105]); MULADD(at[42], at[104]); MULADD(at[43], at[103]); MULADD(at[44], at[102]); MULADD(at[45], at[101]); MULADD(at[46], at[100]); MULADD(at[47], at[99]); MULADD(at[48], at[98]); MULADD(at[49], at[97]); MULADD(at[50], at[96]); MULADD(at[51], at[95]); MULADD(at[52], at[94]); MULADD(at[53], at[93]); MULADD(at[54], at[92]); MULADD(at[55], at[91]); MULADD(at[56], at[90]); MULADD(at[57], at[89]); MULADD(at[58], at[88]); MULADD(at[59], at[87]); MULADD(at[60], at[86]); MULADD(at[61], at[85]); MULADD(at[62], at[84]); MULADD(at[63], at[83]); + COMBA_STORE(C->dp[82]); + /* 83 */ + COMBA_FORWARD; + MULADD(at[20], at[127]); MULADD(at[21], at[126]); MULADD(at[22], at[125]); MULADD(at[23], at[124]); MULADD(at[24], at[123]); MULADD(at[25], at[122]); MULADD(at[26], at[121]); MULADD(at[27], at[120]); MULADD(at[28], at[119]); MULADD(at[29], at[118]); MULADD(at[30], at[117]); MULADD(at[31], at[116]); MULADD(at[32], at[115]); MULADD(at[33], at[114]); MULADD(at[34], at[113]); MULADD(at[35], at[112]); MULADD(at[36], at[111]); MULADD(at[37], at[110]); MULADD(at[38], at[109]); MULADD(at[39], at[108]); MULADD(at[40], at[107]); MULADD(at[41], at[106]); MULADD(at[42], at[105]); MULADD(at[43], at[104]); MULADD(at[44], at[103]); MULADD(at[45], at[102]); MULADD(at[46], at[101]); MULADD(at[47], at[100]); MULADD(at[48], at[99]); MULADD(at[49], at[98]); MULADD(at[50], at[97]); MULADD(at[51], at[96]); MULADD(at[52], at[95]); MULADD(at[53], at[94]); MULADD(at[54], at[93]); MULADD(at[55], at[92]); MULADD(at[56], at[91]); MULADD(at[57], at[90]); MULADD(at[58], at[89]); MULADD(at[59], at[88]); MULADD(at[60], at[87]); MULADD(at[61], at[86]); MULADD(at[62], at[85]); MULADD(at[63], at[84]); + COMBA_STORE(C->dp[83]); + /* 84 */ + COMBA_FORWARD; + MULADD(at[21], at[127]); MULADD(at[22], at[126]); MULADD(at[23], at[125]); MULADD(at[24], at[124]); MULADD(at[25], at[123]); MULADD(at[26], at[122]); MULADD(at[27], at[121]); MULADD(at[28], at[120]); MULADD(at[29], at[119]); MULADD(at[30], at[118]); MULADD(at[31], at[117]); MULADD(at[32], at[116]); MULADD(at[33], at[115]); MULADD(at[34], at[114]); MULADD(at[35], at[113]); MULADD(at[36], at[112]); MULADD(at[37], at[111]); MULADD(at[38], at[110]); MULADD(at[39], at[109]); MULADD(at[40], at[108]); MULADD(at[41], at[107]); MULADD(at[42], at[106]); MULADD(at[43], at[105]); MULADD(at[44], at[104]); MULADD(at[45], at[103]); MULADD(at[46], at[102]); MULADD(at[47], at[101]); MULADD(at[48], at[100]); MULADD(at[49], at[99]); MULADD(at[50], at[98]); MULADD(at[51], at[97]); MULADD(at[52], at[96]); MULADD(at[53], at[95]); MULADD(at[54], at[94]); MULADD(at[55], at[93]); MULADD(at[56], at[92]); MULADD(at[57], at[91]); MULADD(at[58], at[90]); MULADD(at[59], at[89]); MULADD(at[60], at[88]); MULADD(at[61], at[87]); MULADD(at[62], at[86]); MULADD(at[63], at[85]); + COMBA_STORE(C->dp[84]); + /* 85 */ + COMBA_FORWARD; + MULADD(at[22], at[127]); MULADD(at[23], at[126]); MULADD(at[24], at[125]); MULADD(at[25], at[124]); MULADD(at[26], at[123]); MULADD(at[27], at[122]); MULADD(at[28], at[121]); MULADD(at[29], at[120]); MULADD(at[30], at[119]); MULADD(at[31], at[118]); MULADD(at[32], at[117]); MULADD(at[33], at[116]); MULADD(at[34], at[115]); MULADD(at[35], at[114]); MULADD(at[36], at[113]); MULADD(at[37], at[112]); MULADD(at[38], at[111]); MULADD(at[39], at[110]); MULADD(at[40], at[109]); MULADD(at[41], at[108]); MULADD(at[42], at[107]); MULADD(at[43], at[106]); MULADD(at[44], at[105]); MULADD(at[45], at[104]); MULADD(at[46], at[103]); MULADD(at[47], at[102]); MULADD(at[48], at[101]); MULADD(at[49], at[100]); MULADD(at[50], at[99]); MULADD(at[51], at[98]); MULADD(at[52], at[97]); MULADD(at[53], at[96]); MULADD(at[54], at[95]); MULADD(at[55], at[94]); MULADD(at[56], at[93]); MULADD(at[57], at[92]); MULADD(at[58], at[91]); MULADD(at[59], at[90]); MULADD(at[60], at[89]); MULADD(at[61], at[88]); MULADD(at[62], at[87]); MULADD(at[63], at[86]); + COMBA_STORE(C->dp[85]); + /* 86 */ + COMBA_FORWARD; + MULADD(at[23], at[127]); MULADD(at[24], at[126]); MULADD(at[25], at[125]); MULADD(at[26], at[124]); MULADD(at[27], at[123]); MULADD(at[28], at[122]); MULADD(at[29], at[121]); MULADD(at[30], at[120]); MULADD(at[31], at[119]); MULADD(at[32], at[118]); MULADD(at[33], at[117]); MULADD(at[34], at[116]); MULADD(at[35], at[115]); MULADD(at[36], at[114]); MULADD(at[37], at[113]); MULADD(at[38], at[112]); MULADD(at[39], at[111]); MULADD(at[40], at[110]); MULADD(at[41], at[109]); MULADD(at[42], at[108]); MULADD(at[43], at[107]); MULADD(at[44], at[106]); MULADD(at[45], at[105]); MULADD(at[46], at[104]); MULADD(at[47], at[103]); MULADD(at[48], at[102]); MULADD(at[49], at[101]); MULADD(at[50], at[100]); MULADD(at[51], at[99]); MULADD(at[52], at[98]); MULADD(at[53], at[97]); MULADD(at[54], at[96]); MULADD(at[55], at[95]); MULADD(at[56], at[94]); MULADD(at[57], at[93]); MULADD(at[58], at[92]); MULADD(at[59], at[91]); MULADD(at[60], at[90]); MULADD(at[61], at[89]); MULADD(at[62], at[88]); MULADD(at[63], at[87]); + COMBA_STORE(C->dp[86]); + /* 87 */ + COMBA_FORWARD; + MULADD(at[24], at[127]); MULADD(at[25], at[126]); MULADD(at[26], at[125]); MULADD(at[27], at[124]); MULADD(at[28], at[123]); MULADD(at[29], at[122]); MULADD(at[30], at[121]); MULADD(at[31], at[120]); MULADD(at[32], at[119]); MULADD(at[33], at[118]); MULADD(at[34], at[117]); MULADD(at[35], at[116]); MULADD(at[36], at[115]); MULADD(at[37], at[114]); MULADD(at[38], at[113]); MULADD(at[39], at[112]); MULADD(at[40], at[111]); MULADD(at[41], at[110]); MULADD(at[42], at[109]); MULADD(at[43], at[108]); MULADD(at[44], at[107]); MULADD(at[45], at[106]); MULADD(at[46], at[105]); MULADD(at[47], at[104]); MULADD(at[48], at[103]); MULADD(at[49], at[102]); MULADD(at[50], at[101]); MULADD(at[51], at[100]); MULADD(at[52], at[99]); MULADD(at[53], at[98]); MULADD(at[54], at[97]); MULADD(at[55], at[96]); MULADD(at[56], at[95]); MULADD(at[57], at[94]); MULADD(at[58], at[93]); MULADD(at[59], at[92]); MULADD(at[60], at[91]); MULADD(at[61], at[90]); MULADD(at[62], at[89]); MULADD(at[63], at[88]); + COMBA_STORE(C->dp[87]); + /* 88 */ + COMBA_FORWARD; + MULADD(at[25], at[127]); MULADD(at[26], at[126]); MULADD(at[27], at[125]); MULADD(at[28], at[124]); MULADD(at[29], at[123]); MULADD(at[30], at[122]); MULADD(at[31], at[121]); MULADD(at[32], at[120]); MULADD(at[33], at[119]); MULADD(at[34], at[118]); MULADD(at[35], at[117]); MULADD(at[36], at[116]); MULADD(at[37], at[115]); MULADD(at[38], at[114]); MULADD(at[39], at[113]); MULADD(at[40], at[112]); MULADD(at[41], at[111]); MULADD(at[42], at[110]); MULADD(at[43], at[109]); MULADD(at[44], at[108]); MULADD(at[45], at[107]); MULADD(at[46], at[106]); MULADD(at[47], at[105]); MULADD(at[48], at[104]); MULADD(at[49], at[103]); MULADD(at[50], at[102]); MULADD(at[51], at[101]); MULADD(at[52], at[100]); MULADD(at[53], at[99]); MULADD(at[54], at[98]); MULADD(at[55], at[97]); MULADD(at[56], at[96]); MULADD(at[57], at[95]); MULADD(at[58], at[94]); MULADD(at[59], at[93]); MULADD(at[60], at[92]); MULADD(at[61], at[91]); MULADD(at[62], at[90]); MULADD(at[63], at[89]); + COMBA_STORE(C->dp[88]); + /* 89 */ + COMBA_FORWARD; + MULADD(at[26], at[127]); MULADD(at[27], at[126]); MULADD(at[28], at[125]); MULADD(at[29], at[124]); MULADD(at[30], at[123]); MULADD(at[31], at[122]); MULADD(at[32], at[121]); MULADD(at[33], at[120]); MULADD(at[34], at[119]); MULADD(at[35], at[118]); MULADD(at[36], at[117]); MULADD(at[37], at[116]); MULADD(at[38], at[115]); MULADD(at[39], at[114]); MULADD(at[40], at[113]); MULADD(at[41], at[112]); MULADD(at[42], at[111]); MULADD(at[43], at[110]); MULADD(at[44], at[109]); MULADD(at[45], at[108]); MULADD(at[46], at[107]); MULADD(at[47], at[106]); MULADD(at[48], at[105]); MULADD(at[49], at[104]); MULADD(at[50], at[103]); MULADD(at[51], at[102]); MULADD(at[52], at[101]); MULADD(at[53], at[100]); MULADD(at[54], at[99]); MULADD(at[55], at[98]); MULADD(at[56], at[97]); MULADD(at[57], at[96]); MULADD(at[58], at[95]); MULADD(at[59], at[94]); MULADD(at[60], at[93]); MULADD(at[61], at[92]); MULADD(at[62], at[91]); MULADD(at[63], at[90]); + COMBA_STORE(C->dp[89]); + /* 90 */ + COMBA_FORWARD; + MULADD(at[27], at[127]); MULADD(at[28], at[126]); MULADD(at[29], at[125]); MULADD(at[30], at[124]); MULADD(at[31], at[123]); MULADD(at[32], at[122]); MULADD(at[33], at[121]); MULADD(at[34], at[120]); MULADD(at[35], at[119]); MULADD(at[36], at[118]); MULADD(at[37], at[117]); MULADD(at[38], at[116]); MULADD(at[39], at[115]); MULADD(at[40], at[114]); MULADD(at[41], at[113]); MULADD(at[42], at[112]); MULADD(at[43], at[111]); MULADD(at[44], at[110]); MULADD(at[45], at[109]); MULADD(at[46], at[108]); MULADD(at[47], at[107]); MULADD(at[48], at[106]); MULADD(at[49], at[105]); MULADD(at[50], at[104]); MULADD(at[51], at[103]); MULADD(at[52], at[102]); MULADD(at[53], at[101]); MULADD(at[54], at[100]); MULADD(at[55], at[99]); MULADD(at[56], at[98]); MULADD(at[57], at[97]); MULADD(at[58], at[96]); MULADD(at[59], at[95]); MULADD(at[60], at[94]); MULADD(at[61], at[93]); MULADD(at[62], at[92]); MULADD(at[63], at[91]); + COMBA_STORE(C->dp[90]); + /* 91 */ + COMBA_FORWARD; + MULADD(at[28], at[127]); MULADD(at[29], at[126]); MULADD(at[30], at[125]); MULADD(at[31], at[124]); MULADD(at[32], at[123]); MULADD(at[33], at[122]); MULADD(at[34], at[121]); MULADD(at[35], at[120]); MULADD(at[36], at[119]); MULADD(at[37], at[118]); MULADD(at[38], at[117]); MULADD(at[39], at[116]); MULADD(at[40], at[115]); MULADD(at[41], at[114]); MULADD(at[42], at[113]); MULADD(at[43], at[112]); MULADD(at[44], at[111]); MULADD(at[45], at[110]); MULADD(at[46], at[109]); MULADD(at[47], at[108]); MULADD(at[48], at[107]); MULADD(at[49], at[106]); MULADD(at[50], at[105]); MULADD(at[51], at[104]); MULADD(at[52], at[103]); MULADD(at[53], at[102]); MULADD(at[54], at[101]); MULADD(at[55], at[100]); MULADD(at[56], at[99]); MULADD(at[57], at[98]); MULADD(at[58], at[97]); MULADD(at[59], at[96]); MULADD(at[60], at[95]); MULADD(at[61], at[94]); MULADD(at[62], at[93]); MULADD(at[63], at[92]); + COMBA_STORE(C->dp[91]); + /* 92 */ + COMBA_FORWARD; + MULADD(at[29], at[127]); MULADD(at[30], at[126]); MULADD(at[31], at[125]); MULADD(at[32], at[124]); MULADD(at[33], at[123]); MULADD(at[34], at[122]); MULADD(at[35], at[121]); MULADD(at[36], at[120]); MULADD(at[37], at[119]); MULADD(at[38], at[118]); MULADD(at[39], at[117]); MULADD(at[40], at[116]); MULADD(at[41], at[115]); MULADD(at[42], at[114]); MULADD(at[43], at[113]); MULADD(at[44], at[112]); MULADD(at[45], at[111]); MULADD(at[46], at[110]); MULADD(at[47], at[109]); MULADD(at[48], at[108]); MULADD(at[49], at[107]); MULADD(at[50], at[106]); MULADD(at[51], at[105]); MULADD(at[52], at[104]); MULADD(at[53], at[103]); MULADD(at[54], at[102]); MULADD(at[55], at[101]); MULADD(at[56], at[100]); MULADD(at[57], at[99]); MULADD(at[58], at[98]); MULADD(at[59], at[97]); MULADD(at[60], at[96]); MULADD(at[61], at[95]); MULADD(at[62], at[94]); MULADD(at[63], at[93]); + COMBA_STORE(C->dp[92]); + /* 93 */ + COMBA_FORWARD; + MULADD(at[30], at[127]); MULADD(at[31], at[126]); MULADD(at[32], at[125]); MULADD(at[33], at[124]); MULADD(at[34], at[123]); MULADD(at[35], at[122]); MULADD(at[36], at[121]); MULADD(at[37], at[120]); MULADD(at[38], at[119]); MULADD(at[39], at[118]); MULADD(at[40], at[117]); MULADD(at[41], at[116]); MULADD(at[42], at[115]); MULADD(at[43], at[114]); MULADD(at[44], at[113]); MULADD(at[45], at[112]); MULADD(at[46], at[111]); MULADD(at[47], at[110]); MULADD(at[48], at[109]); MULADD(at[49], at[108]); MULADD(at[50], at[107]); MULADD(at[51], at[106]); MULADD(at[52], at[105]); MULADD(at[53], at[104]); MULADD(at[54], at[103]); MULADD(at[55], at[102]); MULADD(at[56], at[101]); MULADD(at[57], at[100]); MULADD(at[58], at[99]); MULADD(at[59], at[98]); MULADD(at[60], at[97]); MULADD(at[61], at[96]); MULADD(at[62], at[95]); MULADD(at[63], at[94]); + COMBA_STORE(C->dp[93]); + /* 94 */ + COMBA_FORWARD; + MULADD(at[31], at[127]); MULADD(at[32], at[126]); MULADD(at[33], at[125]); MULADD(at[34], at[124]); MULADD(at[35], at[123]); MULADD(at[36], at[122]); MULADD(at[37], at[121]); MULADD(at[38], at[120]); MULADD(at[39], at[119]); MULADD(at[40], at[118]); MULADD(at[41], at[117]); MULADD(at[42], at[116]); MULADD(at[43], at[115]); MULADD(at[44], at[114]); MULADD(at[45], at[113]); MULADD(at[46], at[112]); MULADD(at[47], at[111]); MULADD(at[48], at[110]); MULADD(at[49], at[109]); MULADD(at[50], at[108]); MULADD(at[51], at[107]); MULADD(at[52], at[106]); MULADD(at[53], at[105]); MULADD(at[54], at[104]); MULADD(at[55], at[103]); MULADD(at[56], at[102]); MULADD(at[57], at[101]); MULADD(at[58], at[100]); MULADD(at[59], at[99]); MULADD(at[60], at[98]); MULADD(at[61], at[97]); MULADD(at[62], at[96]); MULADD(at[63], at[95]); + COMBA_STORE(C->dp[94]); + /* 95 */ + COMBA_FORWARD; + MULADD(at[32], at[127]); MULADD(at[33], at[126]); MULADD(at[34], at[125]); MULADD(at[35], at[124]); MULADD(at[36], at[123]); MULADD(at[37], at[122]); MULADD(at[38], at[121]); MULADD(at[39], at[120]); MULADD(at[40], at[119]); MULADD(at[41], at[118]); MULADD(at[42], at[117]); MULADD(at[43], at[116]); MULADD(at[44], at[115]); MULADD(at[45], at[114]); MULADD(at[46], at[113]); MULADD(at[47], at[112]); MULADD(at[48], at[111]); MULADD(at[49], at[110]); MULADD(at[50], at[109]); MULADD(at[51], at[108]); MULADD(at[52], at[107]); MULADD(at[53], at[106]); MULADD(at[54], at[105]); MULADD(at[55], at[104]); MULADD(at[56], at[103]); MULADD(at[57], at[102]); MULADD(at[58], at[101]); MULADD(at[59], at[100]); MULADD(at[60], at[99]); MULADD(at[61], at[98]); MULADD(at[62], at[97]); MULADD(at[63], at[96]); + COMBA_STORE(C->dp[95]); + /* 96 */ + COMBA_FORWARD; + MULADD(at[33], at[127]); MULADD(at[34], at[126]); MULADD(at[35], at[125]); MULADD(at[36], at[124]); MULADD(at[37], at[123]); MULADD(at[38], at[122]); MULADD(at[39], at[121]); MULADD(at[40], at[120]); MULADD(at[41], at[119]); MULADD(at[42], at[118]); MULADD(at[43], at[117]); MULADD(at[44], at[116]); MULADD(at[45], at[115]); MULADD(at[46], at[114]); MULADD(at[47], at[113]); MULADD(at[48], at[112]); MULADD(at[49], at[111]); MULADD(at[50], at[110]); MULADD(at[51], at[109]); MULADD(at[52], at[108]); MULADD(at[53], at[107]); MULADD(at[54], at[106]); MULADD(at[55], at[105]); MULADD(at[56], at[104]); MULADD(at[57], at[103]); MULADD(at[58], at[102]); MULADD(at[59], at[101]); MULADD(at[60], at[100]); MULADD(at[61], at[99]); MULADD(at[62], at[98]); MULADD(at[63], at[97]); + COMBA_STORE(C->dp[96]); + /* 97 */ + COMBA_FORWARD; + MULADD(at[34], at[127]); MULADD(at[35], at[126]); MULADD(at[36], at[125]); MULADD(at[37], at[124]); MULADD(at[38], at[123]); MULADD(at[39], at[122]); MULADD(at[40], at[121]); MULADD(at[41], at[120]); MULADD(at[42], at[119]); MULADD(at[43], at[118]); MULADD(at[44], at[117]); MULADD(at[45], at[116]); MULADD(at[46], at[115]); MULADD(at[47], at[114]); MULADD(at[48], at[113]); MULADD(at[49], at[112]); MULADD(at[50], at[111]); MULADD(at[51], at[110]); MULADD(at[52], at[109]); MULADD(at[53], at[108]); MULADD(at[54], at[107]); MULADD(at[55], at[106]); MULADD(at[56], at[105]); MULADD(at[57], at[104]); MULADD(at[58], at[103]); MULADD(at[59], at[102]); MULADD(at[60], at[101]); MULADD(at[61], at[100]); MULADD(at[62], at[99]); MULADD(at[63], at[98]); + COMBA_STORE(C->dp[97]); + /* 98 */ + COMBA_FORWARD; + MULADD(at[35], at[127]); MULADD(at[36], at[126]); MULADD(at[37], at[125]); MULADD(at[38], at[124]); MULADD(at[39], at[123]); MULADD(at[40], at[122]); MULADD(at[41], at[121]); MULADD(at[42], at[120]); MULADD(at[43], at[119]); MULADD(at[44], at[118]); MULADD(at[45], at[117]); MULADD(at[46], at[116]); MULADD(at[47], at[115]); MULADD(at[48], at[114]); MULADD(at[49], at[113]); MULADD(at[50], at[112]); MULADD(at[51], at[111]); MULADD(at[52], at[110]); MULADD(at[53], at[109]); MULADD(at[54], at[108]); MULADD(at[55], at[107]); MULADD(at[56], at[106]); MULADD(at[57], at[105]); MULADD(at[58], at[104]); MULADD(at[59], at[103]); MULADD(at[60], at[102]); MULADD(at[61], at[101]); MULADD(at[62], at[100]); MULADD(at[63], at[99]); + COMBA_STORE(C->dp[98]); + /* 99 */ + COMBA_FORWARD; + MULADD(at[36], at[127]); MULADD(at[37], at[126]); MULADD(at[38], at[125]); MULADD(at[39], at[124]); MULADD(at[40], at[123]); MULADD(at[41], at[122]); MULADD(at[42], at[121]); MULADD(at[43], at[120]); MULADD(at[44], at[119]); MULADD(at[45], at[118]); MULADD(at[46], at[117]); MULADD(at[47], at[116]); MULADD(at[48], at[115]); MULADD(at[49], at[114]); MULADD(at[50], at[113]); MULADD(at[51], at[112]); MULADD(at[52], at[111]); MULADD(at[53], at[110]); MULADD(at[54], at[109]); MULADD(at[55], at[108]); MULADD(at[56], at[107]); MULADD(at[57], at[106]); MULADD(at[58], at[105]); MULADD(at[59], at[104]); MULADD(at[60], at[103]); MULADD(at[61], at[102]); MULADD(at[62], at[101]); MULADD(at[63], at[100]); + COMBA_STORE(C->dp[99]); + /* 100 */ + COMBA_FORWARD; + MULADD(at[37], at[127]); MULADD(at[38], at[126]); MULADD(at[39], at[125]); MULADD(at[40], at[124]); MULADD(at[41], at[123]); MULADD(at[42], at[122]); MULADD(at[43], at[121]); MULADD(at[44], at[120]); MULADD(at[45], at[119]); MULADD(at[46], at[118]); MULADD(at[47], at[117]); MULADD(at[48], at[116]); MULADD(at[49], at[115]); MULADD(at[50], at[114]); MULADD(at[51], at[113]); MULADD(at[52], at[112]); MULADD(at[53], at[111]); MULADD(at[54], at[110]); MULADD(at[55], at[109]); MULADD(at[56], at[108]); MULADD(at[57], at[107]); MULADD(at[58], at[106]); MULADD(at[59], at[105]); MULADD(at[60], at[104]); MULADD(at[61], at[103]); MULADD(at[62], at[102]); MULADD(at[63], at[101]); + COMBA_STORE(C->dp[100]); + /* 101 */ + COMBA_FORWARD; + MULADD(at[38], at[127]); MULADD(at[39], at[126]); MULADD(at[40], at[125]); MULADD(at[41], at[124]); MULADD(at[42], at[123]); MULADD(at[43], at[122]); MULADD(at[44], at[121]); MULADD(at[45], at[120]); MULADD(at[46], at[119]); MULADD(at[47], at[118]); MULADD(at[48], at[117]); MULADD(at[49], at[116]); MULADD(at[50], at[115]); MULADD(at[51], at[114]); MULADD(at[52], at[113]); MULADD(at[53], at[112]); MULADD(at[54], at[111]); MULADD(at[55], at[110]); MULADD(at[56], at[109]); MULADD(at[57], at[108]); MULADD(at[58], at[107]); MULADD(at[59], at[106]); MULADD(at[60], at[105]); MULADD(at[61], at[104]); MULADD(at[62], at[103]); MULADD(at[63], at[102]); + COMBA_STORE(C->dp[101]); + /* 102 */ + COMBA_FORWARD; + MULADD(at[39], at[127]); MULADD(at[40], at[126]); MULADD(at[41], at[125]); MULADD(at[42], at[124]); MULADD(at[43], at[123]); MULADD(at[44], at[122]); MULADD(at[45], at[121]); MULADD(at[46], at[120]); MULADD(at[47], at[119]); MULADD(at[48], at[118]); MULADD(at[49], at[117]); MULADD(at[50], at[116]); MULADD(at[51], at[115]); MULADD(at[52], at[114]); MULADD(at[53], at[113]); MULADD(at[54], at[112]); MULADD(at[55], at[111]); MULADD(at[56], at[110]); MULADD(at[57], at[109]); MULADD(at[58], at[108]); MULADD(at[59], at[107]); MULADD(at[60], at[106]); MULADD(at[61], at[105]); MULADD(at[62], at[104]); MULADD(at[63], at[103]); + COMBA_STORE(C->dp[102]); + /* 103 */ + COMBA_FORWARD; + MULADD(at[40], at[127]); MULADD(at[41], at[126]); MULADD(at[42], at[125]); MULADD(at[43], at[124]); MULADD(at[44], at[123]); MULADD(at[45], at[122]); MULADD(at[46], at[121]); MULADD(at[47], at[120]); MULADD(at[48], at[119]); MULADD(at[49], at[118]); MULADD(at[50], at[117]); MULADD(at[51], at[116]); MULADD(at[52], at[115]); MULADD(at[53], at[114]); MULADD(at[54], at[113]); MULADD(at[55], at[112]); MULADD(at[56], at[111]); MULADD(at[57], at[110]); MULADD(at[58], at[109]); MULADD(at[59], at[108]); MULADD(at[60], at[107]); MULADD(at[61], at[106]); MULADD(at[62], at[105]); MULADD(at[63], at[104]); + COMBA_STORE(C->dp[103]); + /* 104 */ + COMBA_FORWARD; + MULADD(at[41], at[127]); MULADD(at[42], at[126]); MULADD(at[43], at[125]); MULADD(at[44], at[124]); MULADD(at[45], at[123]); MULADD(at[46], at[122]); MULADD(at[47], at[121]); MULADD(at[48], at[120]); MULADD(at[49], at[119]); MULADD(at[50], at[118]); MULADD(at[51], at[117]); MULADD(at[52], at[116]); MULADD(at[53], at[115]); MULADD(at[54], at[114]); MULADD(at[55], at[113]); MULADD(at[56], at[112]); MULADD(at[57], at[111]); MULADD(at[58], at[110]); MULADD(at[59], at[109]); MULADD(at[60], at[108]); MULADD(at[61], at[107]); MULADD(at[62], at[106]); MULADD(at[63], at[105]); + COMBA_STORE(C->dp[104]); + /* 105 */ + COMBA_FORWARD; + MULADD(at[42], at[127]); MULADD(at[43], at[126]); MULADD(at[44], at[125]); MULADD(at[45], at[124]); MULADD(at[46], at[123]); MULADD(at[47], at[122]); MULADD(at[48], at[121]); MULADD(at[49], at[120]); MULADD(at[50], at[119]); MULADD(at[51], at[118]); MULADD(at[52], at[117]); MULADD(at[53], at[116]); MULADD(at[54], at[115]); MULADD(at[55], at[114]); MULADD(at[56], at[113]); MULADD(at[57], at[112]); MULADD(at[58], at[111]); MULADD(at[59], at[110]); MULADD(at[60], at[109]); MULADD(at[61], at[108]); MULADD(at[62], at[107]); MULADD(at[63], at[106]); + COMBA_STORE(C->dp[105]); + /* 106 */ + COMBA_FORWARD; + MULADD(at[43], at[127]); MULADD(at[44], at[126]); MULADD(at[45], at[125]); MULADD(at[46], at[124]); MULADD(at[47], at[123]); MULADD(at[48], at[122]); MULADD(at[49], at[121]); MULADD(at[50], at[120]); MULADD(at[51], at[119]); MULADD(at[52], at[118]); MULADD(at[53], at[117]); MULADD(at[54], at[116]); MULADD(at[55], at[115]); MULADD(at[56], at[114]); MULADD(at[57], at[113]); MULADD(at[58], at[112]); MULADD(at[59], at[111]); MULADD(at[60], at[110]); MULADD(at[61], at[109]); MULADD(at[62], at[108]); MULADD(at[63], at[107]); + COMBA_STORE(C->dp[106]); + /* 107 */ + COMBA_FORWARD; + MULADD(at[44], at[127]); MULADD(at[45], at[126]); MULADD(at[46], at[125]); MULADD(at[47], at[124]); MULADD(at[48], at[123]); MULADD(at[49], at[122]); MULADD(at[50], at[121]); MULADD(at[51], at[120]); MULADD(at[52], at[119]); MULADD(at[53], at[118]); MULADD(at[54], at[117]); MULADD(at[55], at[116]); MULADD(at[56], at[115]); MULADD(at[57], at[114]); MULADD(at[58], at[113]); MULADD(at[59], at[112]); MULADD(at[60], at[111]); MULADD(at[61], at[110]); MULADD(at[62], at[109]); MULADD(at[63], at[108]); + COMBA_STORE(C->dp[107]); + /* 108 */ + COMBA_FORWARD; + MULADD(at[45], at[127]); MULADD(at[46], at[126]); MULADD(at[47], at[125]); MULADD(at[48], at[124]); MULADD(at[49], at[123]); MULADD(at[50], at[122]); MULADD(at[51], at[121]); MULADD(at[52], at[120]); MULADD(at[53], at[119]); MULADD(at[54], at[118]); MULADD(at[55], at[117]); MULADD(at[56], at[116]); MULADD(at[57], at[115]); MULADD(at[58], at[114]); MULADD(at[59], at[113]); MULADD(at[60], at[112]); MULADD(at[61], at[111]); MULADD(at[62], at[110]); MULADD(at[63], at[109]); + COMBA_STORE(C->dp[108]); + /* 109 */ + COMBA_FORWARD; + MULADD(at[46], at[127]); MULADD(at[47], at[126]); MULADD(at[48], at[125]); MULADD(at[49], at[124]); MULADD(at[50], at[123]); MULADD(at[51], at[122]); MULADD(at[52], at[121]); MULADD(at[53], at[120]); MULADD(at[54], at[119]); MULADD(at[55], at[118]); MULADD(at[56], at[117]); MULADD(at[57], at[116]); MULADD(at[58], at[115]); MULADD(at[59], at[114]); MULADD(at[60], at[113]); MULADD(at[61], at[112]); MULADD(at[62], at[111]); MULADD(at[63], at[110]); + COMBA_STORE(C->dp[109]); + /* 110 */ + COMBA_FORWARD; + MULADD(at[47], at[127]); MULADD(at[48], at[126]); MULADD(at[49], at[125]); MULADD(at[50], at[124]); MULADD(at[51], at[123]); MULADD(at[52], at[122]); MULADD(at[53], at[121]); MULADD(at[54], at[120]); MULADD(at[55], at[119]); MULADD(at[56], at[118]); MULADD(at[57], at[117]); MULADD(at[58], at[116]); MULADD(at[59], at[115]); MULADD(at[60], at[114]); MULADD(at[61], at[113]); MULADD(at[62], at[112]); MULADD(at[63], at[111]); + COMBA_STORE(C->dp[110]); + /* 111 */ + COMBA_FORWARD; + MULADD(at[48], at[127]); MULADD(at[49], at[126]); MULADD(at[50], at[125]); MULADD(at[51], at[124]); MULADD(at[52], at[123]); MULADD(at[53], at[122]); MULADD(at[54], at[121]); MULADD(at[55], at[120]); MULADD(at[56], at[119]); MULADD(at[57], at[118]); MULADD(at[58], at[117]); MULADD(at[59], at[116]); MULADD(at[60], at[115]); MULADD(at[61], at[114]); MULADD(at[62], at[113]); MULADD(at[63], at[112]); + COMBA_STORE(C->dp[111]); + /* 112 */ + COMBA_FORWARD; + MULADD(at[49], at[127]); MULADD(at[50], at[126]); MULADD(at[51], at[125]); MULADD(at[52], at[124]); MULADD(at[53], at[123]); MULADD(at[54], at[122]); MULADD(at[55], at[121]); MULADD(at[56], at[120]); MULADD(at[57], at[119]); MULADD(at[58], at[118]); MULADD(at[59], at[117]); MULADD(at[60], at[116]); MULADD(at[61], at[115]); MULADD(at[62], at[114]); MULADD(at[63], at[113]); + COMBA_STORE(C->dp[112]); + /* 113 */ + COMBA_FORWARD; + MULADD(at[50], at[127]); MULADD(at[51], at[126]); MULADD(at[52], at[125]); MULADD(at[53], at[124]); MULADD(at[54], at[123]); MULADD(at[55], at[122]); MULADD(at[56], at[121]); MULADD(at[57], at[120]); MULADD(at[58], at[119]); MULADD(at[59], at[118]); MULADD(at[60], at[117]); MULADD(at[61], at[116]); MULADD(at[62], at[115]); MULADD(at[63], at[114]); + COMBA_STORE(C->dp[113]); + /* 114 */ + COMBA_FORWARD; + MULADD(at[51], at[127]); MULADD(at[52], at[126]); MULADD(at[53], at[125]); MULADD(at[54], at[124]); MULADD(at[55], at[123]); MULADD(at[56], at[122]); MULADD(at[57], at[121]); MULADD(at[58], at[120]); MULADD(at[59], at[119]); MULADD(at[60], at[118]); MULADD(at[61], at[117]); MULADD(at[62], at[116]); MULADD(at[63], at[115]); + COMBA_STORE(C->dp[114]); + /* 115 */ + COMBA_FORWARD; + MULADD(at[52], at[127]); MULADD(at[53], at[126]); MULADD(at[54], at[125]); MULADD(at[55], at[124]); MULADD(at[56], at[123]); MULADD(at[57], at[122]); MULADD(at[58], at[121]); MULADD(at[59], at[120]); MULADD(at[60], at[119]); MULADD(at[61], at[118]); MULADD(at[62], at[117]); MULADD(at[63], at[116]); + COMBA_STORE(C->dp[115]); + /* 116 */ + COMBA_FORWARD; + MULADD(at[53], at[127]); MULADD(at[54], at[126]); MULADD(at[55], at[125]); MULADD(at[56], at[124]); MULADD(at[57], at[123]); MULADD(at[58], at[122]); MULADD(at[59], at[121]); MULADD(at[60], at[120]); MULADD(at[61], at[119]); MULADD(at[62], at[118]); MULADD(at[63], at[117]); + COMBA_STORE(C->dp[116]); + /* 117 */ + COMBA_FORWARD; + MULADD(at[54], at[127]); MULADD(at[55], at[126]); MULADD(at[56], at[125]); MULADD(at[57], at[124]); MULADD(at[58], at[123]); MULADD(at[59], at[122]); MULADD(at[60], at[121]); MULADD(at[61], at[120]); MULADD(at[62], at[119]); MULADD(at[63], at[118]); + COMBA_STORE(C->dp[117]); + /* 118 */ + COMBA_FORWARD; + MULADD(at[55], at[127]); MULADD(at[56], at[126]); MULADD(at[57], at[125]); MULADD(at[58], at[124]); MULADD(at[59], at[123]); MULADD(at[60], at[122]); MULADD(at[61], at[121]); MULADD(at[62], at[120]); MULADD(at[63], at[119]); + COMBA_STORE(C->dp[118]); + /* 119 */ + COMBA_FORWARD; + MULADD(at[56], at[127]); MULADD(at[57], at[126]); MULADD(at[58], at[125]); MULADD(at[59], at[124]); MULADD(at[60], at[123]); MULADD(at[61], at[122]); MULADD(at[62], at[121]); MULADD(at[63], at[120]); + COMBA_STORE(C->dp[119]); + /* 120 */ + COMBA_FORWARD; + MULADD(at[57], at[127]); MULADD(at[58], at[126]); MULADD(at[59], at[125]); MULADD(at[60], at[124]); MULADD(at[61], at[123]); MULADD(at[62], at[122]); MULADD(at[63], at[121]); + COMBA_STORE(C->dp[120]); + /* 121 */ + COMBA_FORWARD; + MULADD(at[58], at[127]); MULADD(at[59], at[126]); MULADD(at[60], at[125]); MULADD(at[61], at[124]); MULADD(at[62], at[123]); MULADD(at[63], at[122]); + COMBA_STORE(C->dp[121]); + /* 122 */ + COMBA_FORWARD; + MULADD(at[59], at[127]); MULADD(at[60], at[126]); MULADD(at[61], at[125]); MULADD(at[62], at[124]); MULADD(at[63], at[123]); + COMBA_STORE(C->dp[122]); + /* 123 */ + COMBA_FORWARD; + MULADD(at[60], at[127]); MULADD(at[61], at[126]); MULADD(at[62], at[125]); MULADD(at[63], at[124]); + COMBA_STORE(C->dp[123]); + /* 124 */ + COMBA_FORWARD; + MULADD(at[61], at[127]); MULADD(at[62], at[126]); MULADD(at[63], at[125]); + COMBA_STORE(C->dp[124]); + /* 125 */ + COMBA_FORWARD; + MULADD(at[62], at[127]); MULADD(at[63], at[126]); + COMBA_STORE(C->dp[125]); + /* 126 */ + COMBA_FORWARD; + MULADD(at[63], at[127]); + COMBA_STORE(C->dp[126]); + COMBA_STORE2(C->dp[127]); + C->used = 128; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; +} + +void fp_mul_comba48(fp_int *A, fp_int *B, fp_int *C) +{ + fp_digit c0, c1, c2, at[96]; + + memcpy(at, A->dp, 48 * sizeof(fp_digit)); + memcpy(at+48, B->dp, 48 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[48]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[49]); MULADD(at[1], at[48]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[50]); MULADD(at[1], at[49]); MULADD(at[2], at[48]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[51]); MULADD(at[1], at[50]); MULADD(at[2], at[49]); MULADD(at[3], at[48]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); + COMBA_STORE(C->dp[12]); + /* 13 */ + 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]); + COMBA_STORE(C->dp[13]); + /* 14 */ + 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]); + COMBA_STORE(C->dp[14]); + /* 15 */ + 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]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[0], at[64]); 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[0], at[65]); MULADD(at[1], at[64]); 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[0], at[66]); MULADD(at[1], at[65]); MULADD(at[2], at[64]); 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[0], at[67]); MULADD(at[1], at[66]); MULADD(at[2], at[65]); MULADD(at[3], at[64]); 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[0], at[68]); MULADD(at[1], at[67]); MULADD(at[2], at[66]); MULADD(at[3], at[65]); MULADD(at[4], at[64]); 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[0], at[69]); MULADD(at[1], at[68]); MULADD(at[2], at[67]); MULADD(at[3], at[66]); MULADD(at[4], at[65]); MULADD(at[5], at[64]); 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]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[0], at[70]); MULADD(at[1], at[69]); MULADD(at[2], at[68]); MULADD(at[3], at[67]); MULADD(at[4], at[66]); MULADD(at[5], at[65]); MULADD(at[6], at[64]); 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]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[0], at[71]); MULADD(at[1], at[70]); MULADD(at[2], at[69]); MULADD(at[3], at[68]); MULADD(at[4], at[67]); MULADD(at[5], at[66]); MULADD(at[6], at[65]); MULADD(at[7], at[64]); 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]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[0], at[72]); MULADD(at[1], at[71]); MULADD(at[2], at[70]); MULADD(at[3], at[69]); MULADD(at[4], at[68]); MULADD(at[5], at[67]); MULADD(at[6], at[66]); MULADD(at[7], at[65]); MULADD(at[8], at[64]); 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]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[0], at[73]); MULADD(at[1], at[72]); MULADD(at[2], at[71]); MULADD(at[3], at[70]); MULADD(at[4], at[69]); MULADD(at[5], at[68]); MULADD(at[6], at[67]); MULADD(at[7], at[66]); MULADD(at[8], at[65]); MULADD(at[9], at[64]); 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]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[0], at[74]); MULADD(at[1], at[73]); MULADD(at[2], at[72]); MULADD(at[3], at[71]); MULADD(at[4], at[70]); MULADD(at[5], at[69]); MULADD(at[6], at[68]); MULADD(at[7], at[67]); MULADD(at[8], at[66]); MULADD(at[9], at[65]); MULADD(at[10], at[64]); 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]); + COMBA_STORE(C->dp[26]); + /* 27 */ + COMBA_FORWARD; + MULADD(at[0], at[75]); MULADD(at[1], at[74]); MULADD(at[2], at[73]); MULADD(at[3], at[72]); MULADD(at[4], at[71]); MULADD(at[5], at[70]); MULADD(at[6], at[69]); MULADD(at[7], at[68]); MULADD(at[8], at[67]); MULADD(at[9], at[66]); MULADD(at[10], at[65]); MULADD(at[11], at[64]); 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]); + COMBA_STORE(C->dp[27]); + /* 28 */ + COMBA_FORWARD; + MULADD(at[0], at[76]); MULADD(at[1], at[75]); MULADD(at[2], at[74]); MULADD(at[3], at[73]); MULADD(at[4], at[72]); MULADD(at[5], at[71]); MULADD(at[6], at[70]); MULADD(at[7], at[69]); MULADD(at[8], at[68]); MULADD(at[9], at[67]); MULADD(at[10], at[66]); MULADD(at[11], at[65]); MULADD(at[12], at[64]); 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]); + COMBA_STORE(C->dp[28]); + /* 29 */ + COMBA_FORWARD; + MULADD(at[0], at[77]); MULADD(at[1], at[76]); MULADD(at[2], at[75]); MULADD(at[3], at[74]); MULADD(at[4], at[73]); MULADD(at[5], at[72]); MULADD(at[6], at[71]); MULADD(at[7], at[70]); MULADD(at[8], at[69]); MULADD(at[9], at[68]); MULADD(at[10], at[67]); MULADD(at[11], at[66]); MULADD(at[12], at[65]); MULADD(at[13], at[64]); 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]); + COMBA_STORE(C->dp[29]); + /* 30 */ + COMBA_FORWARD; + MULADD(at[0], at[78]); MULADD(at[1], at[77]); MULADD(at[2], at[76]); MULADD(at[3], at[75]); MULADD(at[4], at[74]); MULADD(at[5], at[73]); MULADD(at[6], at[72]); MULADD(at[7], at[71]); MULADD(at[8], at[70]); MULADD(at[9], at[69]); MULADD(at[10], at[68]); MULADD(at[11], at[67]); MULADD(at[12], at[66]); MULADD(at[13], at[65]); MULADD(at[14], at[64]); 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]); + COMBA_STORE(C->dp[30]); + /* 31 */ + COMBA_FORWARD; + MULADD(at[0], at[79]); MULADD(at[1], at[78]); MULADD(at[2], at[77]); MULADD(at[3], at[76]); MULADD(at[4], at[75]); MULADD(at[5], at[74]); MULADD(at[6], at[73]); MULADD(at[7], at[72]); MULADD(at[8], at[71]); MULADD(at[9], at[70]); MULADD(at[10], at[69]); MULADD(at[11], at[68]); MULADD(at[12], at[67]); MULADD(at[13], at[66]); MULADD(at[14], at[65]); MULADD(at[15], at[64]); 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[31]); + /* 32 */ + COMBA_FORWARD; + MULADD(at[0], at[80]); MULADD(at[1], at[79]); MULADD(at[2], at[78]); MULADD(at[3], at[77]); MULADD(at[4], at[76]); MULADD(at[5], at[75]); MULADD(at[6], at[74]); MULADD(at[7], at[73]); MULADD(at[8], at[72]); MULADD(at[9], at[71]); MULADD(at[10], at[70]); MULADD(at[11], at[69]); MULADD(at[12], at[68]); MULADD(at[13], at[67]); MULADD(at[14], at[66]); MULADD(at[15], at[65]); MULADD(at[16], at[64]); 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]); MULADD(at[32], at[48]); + COMBA_STORE(C->dp[32]); + /* 33 */ + COMBA_FORWARD; + MULADD(at[0], at[81]); MULADD(at[1], at[80]); MULADD(at[2], at[79]); MULADD(at[3], at[78]); MULADD(at[4], at[77]); MULADD(at[5], at[76]); MULADD(at[6], at[75]); MULADD(at[7], at[74]); MULADD(at[8], at[73]); MULADD(at[9], at[72]); MULADD(at[10], at[71]); MULADD(at[11], at[70]); MULADD(at[12], at[69]); MULADD(at[13], at[68]); MULADD(at[14], at[67]); MULADD(at[15], at[66]); MULADD(at[16], at[65]); MULADD(at[17], at[64]); 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]); MULADD(at[32], at[49]); MULADD(at[33], at[48]); + COMBA_STORE(C->dp[33]); + /* 34 */ + COMBA_FORWARD; + MULADD(at[0], at[82]); MULADD(at[1], at[81]); MULADD(at[2], at[80]); MULADD(at[3], at[79]); MULADD(at[4], at[78]); MULADD(at[5], at[77]); MULADD(at[6], at[76]); MULADD(at[7], at[75]); MULADD(at[8], at[74]); MULADD(at[9], at[73]); MULADD(at[10], at[72]); MULADD(at[11], at[71]); MULADD(at[12], at[70]); MULADD(at[13], at[69]); MULADD(at[14], at[68]); MULADD(at[15], at[67]); MULADD(at[16], at[66]); MULADD(at[17], at[65]); MULADD(at[18], at[64]); 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]); MULADD(at[32], at[50]); MULADD(at[33], at[49]); MULADD(at[34], at[48]); + COMBA_STORE(C->dp[34]); + /* 35 */ + COMBA_FORWARD; + MULADD(at[0], at[83]); MULADD(at[1], at[82]); MULADD(at[2], at[81]); MULADD(at[3], at[80]); MULADD(at[4], at[79]); MULADD(at[5], at[78]); MULADD(at[6], at[77]); MULADD(at[7], at[76]); MULADD(at[8], at[75]); MULADD(at[9], at[74]); MULADD(at[10], at[73]); MULADD(at[11], at[72]); MULADD(at[12], at[71]); MULADD(at[13], at[70]); MULADD(at[14], at[69]); MULADD(at[15], at[68]); MULADD(at[16], at[67]); MULADD(at[17], at[66]); MULADD(at[18], at[65]); MULADD(at[19], at[64]); 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]); MULADD(at[32], at[51]); MULADD(at[33], at[50]); MULADD(at[34], at[49]); MULADD(at[35], at[48]); + COMBA_STORE(C->dp[35]); + /* 36 */ + COMBA_FORWARD; + MULADD(at[0], at[84]); MULADD(at[1], at[83]); MULADD(at[2], at[82]); MULADD(at[3], at[81]); MULADD(at[4], at[80]); MULADD(at[5], at[79]); MULADD(at[6], at[78]); MULADD(at[7], at[77]); MULADD(at[8], at[76]); MULADD(at[9], at[75]); MULADD(at[10], at[74]); MULADD(at[11], at[73]); MULADD(at[12], at[72]); MULADD(at[13], at[71]); MULADD(at[14], at[70]); MULADD(at[15], at[69]); MULADD(at[16], at[68]); MULADD(at[17], at[67]); MULADD(at[18], at[66]); MULADD(at[19], at[65]); MULADD(at[20], at[64]); 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]); MULADD(at[32], at[52]); MULADD(at[33], at[51]); MULADD(at[34], at[50]); MULADD(at[35], at[49]); MULADD(at[36], at[48]); + COMBA_STORE(C->dp[36]); + /* 37 */ + COMBA_FORWARD; + MULADD(at[0], at[85]); MULADD(at[1], at[84]); MULADD(at[2], at[83]); MULADD(at[3], at[82]); MULADD(at[4], at[81]); MULADD(at[5], at[80]); MULADD(at[6], at[79]); MULADD(at[7], at[78]); MULADD(at[8], at[77]); MULADD(at[9], at[76]); MULADD(at[10], at[75]); MULADD(at[11], at[74]); MULADD(at[12], at[73]); MULADD(at[13], at[72]); MULADD(at[14], at[71]); MULADD(at[15], at[70]); MULADD(at[16], at[69]); MULADD(at[17], at[68]); MULADD(at[18], at[67]); MULADD(at[19], at[66]); MULADD(at[20], at[65]); MULADD(at[21], at[64]); 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]); MULADD(at[32], at[53]); MULADD(at[33], at[52]); MULADD(at[34], at[51]); MULADD(at[35], at[50]); MULADD(at[36], at[49]); MULADD(at[37], at[48]); + COMBA_STORE(C->dp[37]); + /* 38 */ + COMBA_FORWARD; + MULADD(at[0], at[86]); MULADD(at[1], at[85]); MULADD(at[2], at[84]); MULADD(at[3], at[83]); MULADD(at[4], at[82]); MULADD(at[5], at[81]); MULADD(at[6], at[80]); MULADD(at[7], at[79]); MULADD(at[8], at[78]); MULADD(at[9], at[77]); MULADD(at[10], at[76]); MULADD(at[11], at[75]); MULADD(at[12], at[74]); MULADD(at[13], at[73]); MULADD(at[14], at[72]); MULADD(at[15], at[71]); MULADD(at[16], at[70]); MULADD(at[17], at[69]); MULADD(at[18], at[68]); MULADD(at[19], at[67]); MULADD(at[20], at[66]); MULADD(at[21], at[65]); MULADD(at[22], at[64]); 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]); MULADD(at[32], at[54]); MULADD(at[33], at[53]); MULADD(at[34], at[52]); MULADD(at[35], at[51]); MULADD(at[36], at[50]); MULADD(at[37], at[49]); MULADD(at[38], at[48]); + COMBA_STORE(C->dp[38]); + /* 39 */ + COMBA_FORWARD; + MULADD(at[0], at[87]); MULADD(at[1], at[86]); MULADD(at[2], at[85]); MULADD(at[3], at[84]); MULADD(at[4], at[83]); MULADD(at[5], at[82]); MULADD(at[6], at[81]); MULADD(at[7], at[80]); MULADD(at[8], at[79]); MULADD(at[9], at[78]); MULADD(at[10], at[77]); MULADD(at[11], at[76]); MULADD(at[12], at[75]); MULADD(at[13], at[74]); MULADD(at[14], at[73]); MULADD(at[15], at[72]); MULADD(at[16], at[71]); MULADD(at[17], at[70]); MULADD(at[18], at[69]); MULADD(at[19], at[68]); MULADD(at[20], at[67]); MULADD(at[21], at[66]); MULADD(at[22], at[65]); MULADD(at[23], at[64]); 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]); MULADD(at[32], at[55]); MULADD(at[33], at[54]); MULADD(at[34], at[53]); MULADD(at[35], at[52]); MULADD(at[36], at[51]); MULADD(at[37], at[50]); MULADD(at[38], at[49]); MULADD(at[39], at[48]); + COMBA_STORE(C->dp[39]); + /* 40 */ + COMBA_FORWARD; + MULADD(at[0], at[88]); MULADD(at[1], at[87]); MULADD(at[2], at[86]); MULADD(at[3], at[85]); MULADD(at[4], at[84]); MULADD(at[5], at[83]); MULADD(at[6], at[82]); MULADD(at[7], at[81]); MULADD(at[8], at[80]); MULADD(at[9], at[79]); MULADD(at[10], at[78]); MULADD(at[11], at[77]); MULADD(at[12], at[76]); MULADD(at[13], at[75]); MULADD(at[14], at[74]); MULADD(at[15], at[73]); MULADD(at[16], at[72]); MULADD(at[17], at[71]); MULADD(at[18], at[70]); MULADD(at[19], at[69]); MULADD(at[20], at[68]); MULADD(at[21], at[67]); MULADD(at[22], at[66]); MULADD(at[23], at[65]); MULADD(at[24], at[64]); 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]); MULADD(at[32], at[56]); MULADD(at[33], at[55]); MULADD(at[34], at[54]); MULADD(at[35], at[53]); MULADD(at[36], at[52]); MULADD(at[37], at[51]); MULADD(at[38], at[50]); MULADD(at[39], at[49]); MULADD(at[40], at[48]); + COMBA_STORE(C->dp[40]); + /* 41 */ + COMBA_FORWARD; + MULADD(at[0], at[89]); MULADD(at[1], at[88]); MULADD(at[2], at[87]); MULADD(at[3], at[86]); MULADD(at[4], at[85]); MULADD(at[5], at[84]); MULADD(at[6], at[83]); MULADD(at[7], at[82]); MULADD(at[8], at[81]); MULADD(at[9], at[80]); MULADD(at[10], at[79]); MULADD(at[11], at[78]); MULADD(at[12], at[77]); MULADD(at[13], at[76]); MULADD(at[14], at[75]); MULADD(at[15], at[74]); MULADD(at[16], at[73]); MULADD(at[17], at[72]); MULADD(at[18], at[71]); MULADD(at[19], at[70]); MULADD(at[20], at[69]); MULADD(at[21], at[68]); MULADD(at[22], at[67]); MULADD(at[23], at[66]); MULADD(at[24], at[65]); MULADD(at[25], at[64]); 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]); MULADD(at[32], at[57]); MULADD(at[33], at[56]); MULADD(at[34], at[55]); MULADD(at[35], at[54]); MULADD(at[36], at[53]); MULADD(at[37], at[52]); MULADD(at[38], at[51]); MULADD(at[39], at[50]); MULADD(at[40], at[49]); MULADD(at[41], at[48]); + COMBA_STORE(C->dp[41]); + /* 42 */ + COMBA_FORWARD; + MULADD(at[0], at[90]); MULADD(at[1], at[89]); MULADD(at[2], at[88]); MULADD(at[3], at[87]); MULADD(at[4], at[86]); MULADD(at[5], at[85]); MULADD(at[6], at[84]); MULADD(at[7], at[83]); MULADD(at[8], at[82]); MULADD(at[9], at[81]); MULADD(at[10], at[80]); MULADD(at[11], at[79]); MULADD(at[12], at[78]); MULADD(at[13], at[77]); MULADD(at[14], at[76]); MULADD(at[15], at[75]); MULADD(at[16], at[74]); MULADD(at[17], at[73]); MULADD(at[18], at[72]); MULADD(at[19], at[71]); MULADD(at[20], at[70]); MULADD(at[21], at[69]); MULADD(at[22], at[68]); MULADD(at[23], at[67]); MULADD(at[24], at[66]); MULADD(at[25], at[65]); MULADD(at[26], at[64]); 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]); MULADD(at[32], at[58]); MULADD(at[33], at[57]); MULADD(at[34], at[56]); MULADD(at[35], at[55]); MULADD(at[36], at[54]); MULADD(at[37], at[53]); MULADD(at[38], at[52]); MULADD(at[39], at[51]); MULADD(at[40], at[50]); MULADD(at[41], at[49]); MULADD(at[42], at[48]); + COMBA_STORE(C->dp[42]); + /* 43 */ + COMBA_FORWARD; + MULADD(at[0], at[91]); MULADD(at[1], at[90]); MULADD(at[2], at[89]); MULADD(at[3], at[88]); MULADD(at[4], at[87]); MULADD(at[5], at[86]); MULADD(at[6], at[85]); MULADD(at[7], at[84]); MULADD(at[8], at[83]); MULADD(at[9], at[82]); MULADD(at[10], at[81]); MULADD(at[11], at[80]); MULADD(at[12], at[79]); MULADD(at[13], at[78]); MULADD(at[14], at[77]); MULADD(at[15], at[76]); MULADD(at[16], at[75]); MULADD(at[17], at[74]); MULADD(at[18], at[73]); MULADD(at[19], at[72]); MULADD(at[20], at[71]); MULADD(at[21], at[70]); MULADD(at[22], at[69]); MULADD(at[23], at[68]); MULADD(at[24], at[67]); MULADD(at[25], at[66]); MULADD(at[26], at[65]); MULADD(at[27], at[64]); MULADD(at[28], at[63]); MULADD(at[29], at[62]); MULADD(at[30], at[61]); MULADD(at[31], at[60]); MULADD(at[32], at[59]); MULADD(at[33], at[58]); MULADD(at[34], at[57]); MULADD(at[35], at[56]); MULADD(at[36], at[55]); MULADD(at[37], at[54]); MULADD(at[38], at[53]); MULADD(at[39], at[52]); MULADD(at[40], at[51]); MULADD(at[41], at[50]); MULADD(at[42], at[49]); MULADD(at[43], at[48]); + COMBA_STORE(C->dp[43]); + /* 44 */ + COMBA_FORWARD; + MULADD(at[0], at[92]); MULADD(at[1], at[91]); MULADD(at[2], at[90]); MULADD(at[3], at[89]); MULADD(at[4], at[88]); MULADD(at[5], at[87]); MULADD(at[6], at[86]); MULADD(at[7], at[85]); MULADD(at[8], at[84]); MULADD(at[9], at[83]); MULADD(at[10], at[82]); MULADD(at[11], at[81]); MULADD(at[12], at[80]); MULADD(at[13], at[79]); MULADD(at[14], at[78]); MULADD(at[15], at[77]); MULADD(at[16], at[76]); MULADD(at[17], at[75]); MULADD(at[18], at[74]); MULADD(at[19], at[73]); MULADD(at[20], at[72]); MULADD(at[21], at[71]); MULADD(at[22], at[70]); MULADD(at[23], at[69]); MULADD(at[24], at[68]); MULADD(at[25], at[67]); MULADD(at[26], at[66]); MULADD(at[27], at[65]); MULADD(at[28], at[64]); MULADD(at[29], at[63]); MULADD(at[30], at[62]); MULADD(at[31], at[61]); MULADD(at[32], at[60]); MULADD(at[33], at[59]); MULADD(at[34], at[58]); MULADD(at[35], at[57]); MULADD(at[36], at[56]); MULADD(at[37], at[55]); MULADD(at[38], at[54]); MULADD(at[39], at[53]); MULADD(at[40], at[52]); MULADD(at[41], at[51]); MULADD(at[42], at[50]); MULADD(at[43], at[49]); MULADD(at[44], at[48]); + COMBA_STORE(C->dp[44]); + /* 45 */ + COMBA_FORWARD; + MULADD(at[0], at[93]); MULADD(at[1], at[92]); MULADD(at[2], at[91]); MULADD(at[3], at[90]); MULADD(at[4], at[89]); MULADD(at[5], at[88]); MULADD(at[6], at[87]); MULADD(at[7], at[86]); MULADD(at[8], at[85]); MULADD(at[9], at[84]); MULADD(at[10], at[83]); MULADD(at[11], at[82]); MULADD(at[12], at[81]); MULADD(at[13], at[80]); MULADD(at[14], at[79]); MULADD(at[15], at[78]); MULADD(at[16], at[77]); MULADD(at[17], at[76]); MULADD(at[18], at[75]); MULADD(at[19], at[74]); MULADD(at[20], at[73]); MULADD(at[21], at[72]); MULADD(at[22], at[71]); MULADD(at[23], at[70]); MULADD(at[24], at[69]); MULADD(at[25], at[68]); MULADD(at[26], at[67]); MULADD(at[27], at[66]); MULADD(at[28], at[65]); MULADD(at[29], at[64]); MULADD(at[30], at[63]); MULADD(at[31], at[62]); MULADD(at[32], at[61]); MULADD(at[33], at[60]); MULADD(at[34], at[59]); MULADD(at[35], at[58]); MULADD(at[36], at[57]); MULADD(at[37], at[56]); MULADD(at[38], at[55]); MULADD(at[39], at[54]); MULADD(at[40], at[53]); MULADD(at[41], at[52]); MULADD(at[42], at[51]); MULADD(at[43], at[50]); MULADD(at[44], at[49]); MULADD(at[45], at[48]); + COMBA_STORE(C->dp[45]); + /* 46 */ + COMBA_FORWARD; + MULADD(at[0], at[94]); MULADD(at[1], at[93]); MULADD(at[2], at[92]); MULADD(at[3], at[91]); MULADD(at[4], at[90]); MULADD(at[5], at[89]); MULADD(at[6], at[88]); MULADD(at[7], at[87]); MULADD(at[8], at[86]); MULADD(at[9], at[85]); MULADD(at[10], at[84]); MULADD(at[11], at[83]); MULADD(at[12], at[82]); MULADD(at[13], at[81]); MULADD(at[14], at[80]); MULADD(at[15], at[79]); MULADD(at[16], at[78]); MULADD(at[17], at[77]); MULADD(at[18], at[76]); MULADD(at[19], at[75]); MULADD(at[20], at[74]); MULADD(at[21], at[73]); MULADD(at[22], at[72]); MULADD(at[23], at[71]); MULADD(at[24], at[70]); MULADD(at[25], at[69]); MULADD(at[26], at[68]); MULADD(at[27], at[67]); MULADD(at[28], at[66]); MULADD(at[29], at[65]); MULADD(at[30], at[64]); MULADD(at[31], at[63]); MULADD(at[32], at[62]); MULADD(at[33], at[61]); MULADD(at[34], at[60]); MULADD(at[35], at[59]); MULADD(at[36], at[58]); MULADD(at[37], at[57]); MULADD(at[38], at[56]); MULADD(at[39], at[55]); MULADD(at[40], at[54]); MULADD(at[41], at[53]); MULADD(at[42], at[52]); MULADD(at[43], at[51]); MULADD(at[44], at[50]); MULADD(at[45], at[49]); MULADD(at[46], at[48]); + COMBA_STORE(C->dp[46]); + /* 47 */ + COMBA_FORWARD; + MULADD(at[0], at[95]); MULADD(at[1], at[94]); MULADD(at[2], at[93]); MULADD(at[3], at[92]); MULADD(at[4], at[91]); MULADD(at[5], at[90]); MULADD(at[6], at[89]); MULADD(at[7], at[88]); MULADD(at[8], at[87]); MULADD(at[9], at[86]); MULADD(at[10], at[85]); MULADD(at[11], at[84]); MULADD(at[12], at[83]); MULADD(at[13], at[82]); MULADD(at[14], at[81]); MULADD(at[15], at[80]); MULADD(at[16], at[79]); MULADD(at[17], at[78]); MULADD(at[18], at[77]); MULADD(at[19], at[76]); MULADD(at[20], at[75]); MULADD(at[21], at[74]); MULADD(at[22], at[73]); MULADD(at[23], at[72]); MULADD(at[24], at[71]); MULADD(at[25], at[70]); MULADD(at[26], at[69]); MULADD(at[27], at[68]); MULADD(at[28], at[67]); MULADD(at[29], at[66]); MULADD(at[30], at[65]); MULADD(at[31], at[64]); MULADD(at[32], at[63]); MULADD(at[33], at[62]); MULADD(at[34], at[61]); MULADD(at[35], at[60]); MULADD(at[36], at[59]); MULADD(at[37], at[58]); MULADD(at[38], at[57]); MULADD(at[39], at[56]); MULADD(at[40], at[55]); MULADD(at[41], at[54]); MULADD(at[42], at[53]); MULADD(at[43], at[52]); MULADD(at[44], at[51]); MULADD(at[45], at[50]); MULADD(at[46], at[49]); MULADD(at[47], at[48]); + COMBA_STORE(C->dp[47]); + /* 48 */ + COMBA_FORWARD; + MULADD(at[1], at[95]); MULADD(at[2], at[94]); MULADD(at[3], at[93]); MULADD(at[4], at[92]); MULADD(at[5], at[91]); MULADD(at[6], at[90]); MULADD(at[7], at[89]); MULADD(at[8], at[88]); MULADD(at[9], at[87]); MULADD(at[10], at[86]); MULADD(at[11], at[85]); MULADD(at[12], at[84]); MULADD(at[13], at[83]); MULADD(at[14], at[82]); MULADD(at[15], at[81]); MULADD(at[16], at[80]); MULADD(at[17], at[79]); MULADD(at[18], at[78]); MULADD(at[19], at[77]); MULADD(at[20], at[76]); MULADD(at[21], at[75]); MULADD(at[22], at[74]); MULADD(at[23], at[73]); MULADD(at[24], at[72]); MULADD(at[25], at[71]); MULADD(at[26], at[70]); MULADD(at[27], at[69]); MULADD(at[28], at[68]); MULADD(at[29], at[67]); MULADD(at[30], at[66]); MULADD(at[31], at[65]); MULADD(at[32], at[64]); MULADD(at[33], at[63]); MULADD(at[34], at[62]); MULADD(at[35], at[61]); MULADD(at[36], at[60]); MULADD(at[37], at[59]); MULADD(at[38], at[58]); MULADD(at[39], at[57]); MULADD(at[40], at[56]); MULADD(at[41], at[55]); MULADD(at[42], at[54]); MULADD(at[43], at[53]); MULADD(at[44], at[52]); MULADD(at[45], at[51]); MULADD(at[46], at[50]); MULADD(at[47], at[49]); + COMBA_STORE(C->dp[48]); + /* 49 */ + COMBA_FORWARD; + MULADD(at[2], at[95]); MULADD(at[3], at[94]); MULADD(at[4], at[93]); MULADD(at[5], at[92]); MULADD(at[6], at[91]); MULADD(at[7], at[90]); MULADD(at[8], at[89]); MULADD(at[9], at[88]); MULADD(at[10], at[87]); MULADD(at[11], at[86]); MULADD(at[12], at[85]); MULADD(at[13], at[84]); MULADD(at[14], at[83]); MULADD(at[15], at[82]); MULADD(at[16], at[81]); MULADD(at[17], at[80]); MULADD(at[18], at[79]); MULADD(at[19], at[78]); MULADD(at[20], at[77]); MULADD(at[21], at[76]); MULADD(at[22], at[75]); MULADD(at[23], at[74]); MULADD(at[24], at[73]); MULADD(at[25], at[72]); MULADD(at[26], at[71]); MULADD(at[27], at[70]); MULADD(at[28], at[69]); MULADD(at[29], at[68]); MULADD(at[30], at[67]); MULADD(at[31], at[66]); MULADD(at[32], at[65]); MULADD(at[33], at[64]); MULADD(at[34], at[63]); MULADD(at[35], at[62]); MULADD(at[36], at[61]); MULADD(at[37], at[60]); MULADD(at[38], at[59]); MULADD(at[39], at[58]); MULADD(at[40], at[57]); MULADD(at[41], at[56]); MULADD(at[42], at[55]); MULADD(at[43], at[54]); MULADD(at[44], at[53]); MULADD(at[45], at[52]); MULADD(at[46], at[51]); MULADD(at[47], at[50]); + COMBA_STORE(C->dp[49]); + /* 50 */ + COMBA_FORWARD; + MULADD(at[3], at[95]); MULADD(at[4], at[94]); MULADD(at[5], at[93]); MULADD(at[6], at[92]); MULADD(at[7], at[91]); MULADD(at[8], at[90]); MULADD(at[9], at[89]); MULADD(at[10], at[88]); MULADD(at[11], at[87]); MULADD(at[12], at[86]); MULADD(at[13], at[85]); MULADD(at[14], at[84]); MULADD(at[15], at[83]); MULADD(at[16], at[82]); MULADD(at[17], at[81]); MULADD(at[18], at[80]); MULADD(at[19], at[79]); MULADD(at[20], at[78]); MULADD(at[21], at[77]); MULADD(at[22], at[76]); MULADD(at[23], at[75]); MULADD(at[24], at[74]); MULADD(at[25], at[73]); MULADD(at[26], at[72]); MULADD(at[27], at[71]); MULADD(at[28], at[70]); MULADD(at[29], at[69]); MULADD(at[30], at[68]); MULADD(at[31], at[67]); MULADD(at[32], at[66]); MULADD(at[33], at[65]); MULADD(at[34], at[64]); MULADD(at[35], at[63]); MULADD(at[36], at[62]); MULADD(at[37], at[61]); MULADD(at[38], at[60]); MULADD(at[39], at[59]); MULADD(at[40], at[58]); MULADD(at[41], at[57]); MULADD(at[42], at[56]); MULADD(at[43], at[55]); MULADD(at[44], at[54]); MULADD(at[45], at[53]); MULADD(at[46], at[52]); MULADD(at[47], at[51]); + COMBA_STORE(C->dp[50]); + /* 51 */ + COMBA_FORWARD; + MULADD(at[4], at[95]); MULADD(at[5], at[94]); MULADD(at[6], at[93]); MULADD(at[7], at[92]); MULADD(at[8], at[91]); MULADD(at[9], at[90]); MULADD(at[10], at[89]); MULADD(at[11], at[88]); MULADD(at[12], at[87]); MULADD(at[13], at[86]); MULADD(at[14], at[85]); MULADD(at[15], at[84]); MULADD(at[16], at[83]); MULADD(at[17], at[82]); MULADD(at[18], at[81]); MULADD(at[19], at[80]); MULADD(at[20], at[79]); MULADD(at[21], at[78]); MULADD(at[22], at[77]); MULADD(at[23], at[76]); MULADD(at[24], at[75]); MULADD(at[25], at[74]); MULADD(at[26], at[73]); MULADD(at[27], at[72]); MULADD(at[28], at[71]); MULADD(at[29], at[70]); MULADD(at[30], at[69]); MULADD(at[31], at[68]); MULADD(at[32], at[67]); MULADD(at[33], at[66]); MULADD(at[34], at[65]); MULADD(at[35], at[64]); MULADD(at[36], at[63]); MULADD(at[37], at[62]); MULADD(at[38], at[61]); MULADD(at[39], at[60]); MULADD(at[40], at[59]); MULADD(at[41], at[58]); MULADD(at[42], at[57]); MULADD(at[43], at[56]); MULADD(at[44], at[55]); MULADD(at[45], at[54]); MULADD(at[46], at[53]); MULADD(at[47], at[52]); + COMBA_STORE(C->dp[51]); + /* 52 */ + COMBA_FORWARD; + MULADD(at[5], at[95]); MULADD(at[6], at[94]); MULADD(at[7], at[93]); MULADD(at[8], at[92]); MULADD(at[9], at[91]); MULADD(at[10], at[90]); MULADD(at[11], at[89]); MULADD(at[12], at[88]); MULADD(at[13], at[87]); MULADD(at[14], at[86]); MULADD(at[15], at[85]); MULADD(at[16], at[84]); MULADD(at[17], at[83]); MULADD(at[18], at[82]); MULADD(at[19], at[81]); MULADD(at[20], at[80]); MULADD(at[21], at[79]); MULADD(at[22], at[78]); MULADD(at[23], at[77]); MULADD(at[24], at[76]); MULADD(at[25], at[75]); MULADD(at[26], at[74]); MULADD(at[27], at[73]); MULADD(at[28], at[72]); MULADD(at[29], at[71]); MULADD(at[30], at[70]); MULADD(at[31], at[69]); MULADD(at[32], at[68]); MULADD(at[33], at[67]); MULADD(at[34], at[66]); MULADD(at[35], at[65]); MULADD(at[36], at[64]); MULADD(at[37], at[63]); MULADD(at[38], at[62]); MULADD(at[39], at[61]); MULADD(at[40], at[60]); MULADD(at[41], at[59]); MULADD(at[42], at[58]); MULADD(at[43], at[57]); MULADD(at[44], at[56]); MULADD(at[45], at[55]); MULADD(at[46], at[54]); MULADD(at[47], at[53]); + COMBA_STORE(C->dp[52]); + /* 53 */ + COMBA_FORWARD; + MULADD(at[6], at[95]); MULADD(at[7], at[94]); MULADD(at[8], at[93]); MULADD(at[9], at[92]); MULADD(at[10], at[91]); MULADD(at[11], at[90]); MULADD(at[12], at[89]); MULADD(at[13], at[88]); MULADD(at[14], at[87]); MULADD(at[15], at[86]); MULADD(at[16], at[85]); MULADD(at[17], at[84]); MULADD(at[18], at[83]); MULADD(at[19], at[82]); MULADD(at[20], at[81]); MULADD(at[21], at[80]); MULADD(at[22], at[79]); MULADD(at[23], at[78]); MULADD(at[24], at[77]); MULADD(at[25], at[76]); MULADD(at[26], at[75]); MULADD(at[27], at[74]); MULADD(at[28], at[73]); MULADD(at[29], at[72]); MULADD(at[30], at[71]); MULADD(at[31], at[70]); MULADD(at[32], at[69]); MULADD(at[33], at[68]); MULADD(at[34], at[67]); MULADD(at[35], at[66]); MULADD(at[36], at[65]); MULADD(at[37], at[64]); MULADD(at[38], at[63]); MULADD(at[39], at[62]); MULADD(at[40], at[61]); MULADD(at[41], at[60]); MULADD(at[42], at[59]); MULADD(at[43], at[58]); MULADD(at[44], at[57]); MULADD(at[45], at[56]); MULADD(at[46], at[55]); MULADD(at[47], at[54]); + COMBA_STORE(C->dp[53]); + /* 54 */ + COMBA_FORWARD; + MULADD(at[7], at[95]); MULADD(at[8], at[94]); MULADD(at[9], at[93]); MULADD(at[10], at[92]); MULADD(at[11], at[91]); MULADD(at[12], at[90]); MULADD(at[13], at[89]); MULADD(at[14], at[88]); MULADD(at[15], at[87]); MULADD(at[16], at[86]); MULADD(at[17], at[85]); MULADD(at[18], at[84]); MULADD(at[19], at[83]); MULADD(at[20], at[82]); MULADD(at[21], at[81]); MULADD(at[22], at[80]); MULADD(at[23], at[79]); MULADD(at[24], at[78]); MULADD(at[25], at[77]); MULADD(at[26], at[76]); MULADD(at[27], at[75]); MULADD(at[28], at[74]); MULADD(at[29], at[73]); MULADD(at[30], at[72]); MULADD(at[31], at[71]); MULADD(at[32], at[70]); MULADD(at[33], at[69]); MULADD(at[34], at[68]); MULADD(at[35], at[67]); MULADD(at[36], at[66]); MULADD(at[37], at[65]); MULADD(at[38], at[64]); MULADD(at[39], at[63]); MULADD(at[40], at[62]); MULADD(at[41], at[61]); MULADD(at[42], at[60]); MULADD(at[43], at[59]); MULADD(at[44], at[58]); MULADD(at[45], at[57]); MULADD(at[46], at[56]); MULADD(at[47], at[55]); + COMBA_STORE(C->dp[54]); + /* 55 */ + COMBA_FORWARD; + MULADD(at[8], at[95]); MULADD(at[9], at[94]); MULADD(at[10], at[93]); MULADD(at[11], at[92]); MULADD(at[12], at[91]); MULADD(at[13], at[90]); MULADD(at[14], at[89]); MULADD(at[15], at[88]); MULADD(at[16], at[87]); MULADD(at[17], at[86]); MULADD(at[18], at[85]); MULADD(at[19], at[84]); MULADD(at[20], at[83]); MULADD(at[21], at[82]); MULADD(at[22], at[81]); MULADD(at[23], at[80]); MULADD(at[24], at[79]); MULADD(at[25], at[78]); MULADD(at[26], at[77]); MULADD(at[27], at[76]); MULADD(at[28], at[75]); MULADD(at[29], at[74]); MULADD(at[30], at[73]); MULADD(at[31], at[72]); MULADD(at[32], at[71]); MULADD(at[33], at[70]); MULADD(at[34], at[69]); MULADD(at[35], at[68]); MULADD(at[36], at[67]); MULADD(at[37], at[66]); MULADD(at[38], at[65]); MULADD(at[39], at[64]); MULADD(at[40], at[63]); MULADD(at[41], at[62]); MULADD(at[42], at[61]); MULADD(at[43], at[60]); MULADD(at[44], at[59]); MULADD(at[45], at[58]); MULADD(at[46], at[57]); MULADD(at[47], at[56]); + COMBA_STORE(C->dp[55]); + /* 56 */ + COMBA_FORWARD; + MULADD(at[9], at[95]); MULADD(at[10], at[94]); MULADD(at[11], at[93]); MULADD(at[12], at[92]); MULADD(at[13], at[91]); MULADD(at[14], at[90]); MULADD(at[15], at[89]); MULADD(at[16], at[88]); MULADD(at[17], at[87]); MULADD(at[18], at[86]); MULADD(at[19], at[85]); MULADD(at[20], at[84]); MULADD(at[21], at[83]); MULADD(at[22], at[82]); MULADD(at[23], at[81]); MULADD(at[24], at[80]); MULADD(at[25], at[79]); MULADD(at[26], at[78]); MULADD(at[27], at[77]); MULADD(at[28], at[76]); MULADD(at[29], at[75]); MULADD(at[30], at[74]); MULADD(at[31], at[73]); MULADD(at[32], at[72]); MULADD(at[33], at[71]); MULADD(at[34], at[70]); MULADD(at[35], at[69]); MULADD(at[36], at[68]); MULADD(at[37], at[67]); MULADD(at[38], at[66]); MULADD(at[39], at[65]); MULADD(at[40], at[64]); MULADD(at[41], at[63]); MULADD(at[42], at[62]); MULADD(at[43], at[61]); MULADD(at[44], at[60]); MULADD(at[45], at[59]); MULADD(at[46], at[58]); MULADD(at[47], at[57]); + COMBA_STORE(C->dp[56]); + /* 57 */ + COMBA_FORWARD; + MULADD(at[10], at[95]); MULADD(at[11], at[94]); MULADD(at[12], at[93]); MULADD(at[13], at[92]); MULADD(at[14], at[91]); MULADD(at[15], at[90]); MULADD(at[16], at[89]); MULADD(at[17], at[88]); MULADD(at[18], at[87]); MULADD(at[19], at[86]); MULADD(at[20], at[85]); MULADD(at[21], at[84]); MULADD(at[22], at[83]); MULADD(at[23], at[82]); MULADD(at[24], at[81]); MULADD(at[25], at[80]); MULADD(at[26], at[79]); MULADD(at[27], at[78]); MULADD(at[28], at[77]); MULADD(at[29], at[76]); MULADD(at[30], at[75]); MULADD(at[31], at[74]); MULADD(at[32], at[73]); MULADD(at[33], at[72]); MULADD(at[34], at[71]); MULADD(at[35], at[70]); MULADD(at[36], at[69]); MULADD(at[37], at[68]); MULADD(at[38], at[67]); MULADD(at[39], at[66]); MULADD(at[40], at[65]); MULADD(at[41], at[64]); MULADD(at[42], at[63]); MULADD(at[43], at[62]); MULADD(at[44], at[61]); MULADD(at[45], at[60]); MULADD(at[46], at[59]); MULADD(at[47], at[58]); + COMBA_STORE(C->dp[57]); + /* 58 */ + COMBA_FORWARD; + MULADD(at[11], at[95]); MULADD(at[12], at[94]); MULADD(at[13], at[93]); MULADD(at[14], at[92]); MULADD(at[15], at[91]); MULADD(at[16], at[90]); MULADD(at[17], at[89]); MULADD(at[18], at[88]); MULADD(at[19], at[87]); MULADD(at[20], at[86]); MULADD(at[21], at[85]); MULADD(at[22], at[84]); MULADD(at[23], at[83]); MULADD(at[24], at[82]); MULADD(at[25], at[81]); MULADD(at[26], at[80]); MULADD(at[27], at[79]); MULADD(at[28], at[78]); MULADD(at[29], at[77]); MULADD(at[30], at[76]); MULADD(at[31], at[75]); MULADD(at[32], at[74]); MULADD(at[33], at[73]); MULADD(at[34], at[72]); MULADD(at[35], at[71]); MULADD(at[36], at[70]); MULADD(at[37], at[69]); MULADD(at[38], at[68]); MULADD(at[39], at[67]); MULADD(at[40], at[66]); MULADD(at[41], at[65]); MULADD(at[42], at[64]); MULADD(at[43], at[63]); MULADD(at[44], at[62]); MULADD(at[45], at[61]); MULADD(at[46], at[60]); MULADD(at[47], at[59]); + COMBA_STORE(C->dp[58]); + /* 59 */ + COMBA_FORWARD; + MULADD(at[12], at[95]); MULADD(at[13], at[94]); MULADD(at[14], at[93]); MULADD(at[15], at[92]); MULADD(at[16], at[91]); MULADD(at[17], at[90]); MULADD(at[18], at[89]); MULADD(at[19], at[88]); MULADD(at[20], at[87]); MULADD(at[21], at[86]); MULADD(at[22], at[85]); MULADD(at[23], at[84]); MULADD(at[24], at[83]); MULADD(at[25], at[82]); MULADD(at[26], at[81]); MULADD(at[27], at[80]); MULADD(at[28], at[79]); MULADD(at[29], at[78]); MULADD(at[30], at[77]); MULADD(at[31], at[76]); MULADD(at[32], at[75]); MULADD(at[33], at[74]); MULADD(at[34], at[73]); MULADD(at[35], at[72]); MULADD(at[36], at[71]); MULADD(at[37], at[70]); MULADD(at[38], at[69]); MULADD(at[39], at[68]); MULADD(at[40], at[67]); MULADD(at[41], at[66]); MULADD(at[42], at[65]); MULADD(at[43], at[64]); MULADD(at[44], at[63]); MULADD(at[45], at[62]); MULADD(at[46], at[61]); MULADD(at[47], at[60]); + COMBA_STORE(C->dp[59]); + /* 60 */ + COMBA_FORWARD; + MULADD(at[13], at[95]); MULADD(at[14], at[94]); MULADD(at[15], at[93]); MULADD(at[16], at[92]); MULADD(at[17], at[91]); MULADD(at[18], at[90]); MULADD(at[19], at[89]); MULADD(at[20], at[88]); MULADD(at[21], at[87]); MULADD(at[22], at[86]); MULADD(at[23], at[85]); MULADD(at[24], at[84]); MULADD(at[25], at[83]); MULADD(at[26], at[82]); MULADD(at[27], at[81]); MULADD(at[28], at[80]); MULADD(at[29], at[79]); MULADD(at[30], at[78]); MULADD(at[31], at[77]); MULADD(at[32], at[76]); MULADD(at[33], at[75]); MULADD(at[34], at[74]); MULADD(at[35], at[73]); MULADD(at[36], at[72]); MULADD(at[37], at[71]); MULADD(at[38], at[70]); MULADD(at[39], at[69]); MULADD(at[40], at[68]); MULADD(at[41], at[67]); MULADD(at[42], at[66]); MULADD(at[43], at[65]); MULADD(at[44], at[64]); MULADD(at[45], at[63]); MULADD(at[46], at[62]); MULADD(at[47], at[61]); + COMBA_STORE(C->dp[60]); + /* 61 */ + COMBA_FORWARD; + MULADD(at[14], at[95]); MULADD(at[15], at[94]); MULADD(at[16], at[93]); MULADD(at[17], at[92]); MULADD(at[18], at[91]); MULADD(at[19], at[90]); MULADD(at[20], at[89]); MULADD(at[21], at[88]); MULADD(at[22], at[87]); MULADD(at[23], at[86]); MULADD(at[24], at[85]); MULADD(at[25], at[84]); MULADD(at[26], at[83]); MULADD(at[27], at[82]); MULADD(at[28], at[81]); MULADD(at[29], at[80]); MULADD(at[30], at[79]); MULADD(at[31], at[78]); MULADD(at[32], at[77]); MULADD(at[33], at[76]); MULADD(at[34], at[75]); MULADD(at[35], at[74]); MULADD(at[36], at[73]); MULADD(at[37], at[72]); MULADD(at[38], at[71]); MULADD(at[39], at[70]); MULADD(at[40], at[69]); MULADD(at[41], at[68]); MULADD(at[42], at[67]); MULADD(at[43], at[66]); MULADD(at[44], at[65]); MULADD(at[45], at[64]); MULADD(at[46], at[63]); MULADD(at[47], at[62]); + COMBA_STORE(C->dp[61]); + /* 62 */ + COMBA_FORWARD; + MULADD(at[15], at[95]); MULADD(at[16], at[94]); MULADD(at[17], at[93]); MULADD(at[18], at[92]); MULADD(at[19], at[91]); MULADD(at[20], at[90]); MULADD(at[21], at[89]); MULADD(at[22], at[88]); MULADD(at[23], at[87]); MULADD(at[24], at[86]); MULADD(at[25], at[85]); MULADD(at[26], at[84]); MULADD(at[27], at[83]); MULADD(at[28], at[82]); MULADD(at[29], at[81]); MULADD(at[30], at[80]); MULADD(at[31], at[79]); MULADD(at[32], at[78]); MULADD(at[33], at[77]); MULADD(at[34], at[76]); MULADD(at[35], at[75]); MULADD(at[36], at[74]); MULADD(at[37], at[73]); MULADD(at[38], at[72]); MULADD(at[39], at[71]); MULADD(at[40], at[70]); MULADD(at[41], at[69]); MULADD(at[42], at[68]); MULADD(at[43], at[67]); MULADD(at[44], at[66]); MULADD(at[45], at[65]); MULADD(at[46], at[64]); MULADD(at[47], at[63]); + COMBA_STORE(C->dp[62]); + /* 63 */ + COMBA_FORWARD; + MULADD(at[16], at[95]); MULADD(at[17], at[94]); MULADD(at[18], at[93]); MULADD(at[19], at[92]); MULADD(at[20], at[91]); MULADD(at[21], at[90]); MULADD(at[22], at[89]); MULADD(at[23], at[88]); MULADD(at[24], at[87]); MULADD(at[25], at[86]); MULADD(at[26], at[85]); MULADD(at[27], at[84]); MULADD(at[28], at[83]); MULADD(at[29], at[82]); MULADD(at[30], at[81]); MULADD(at[31], at[80]); MULADD(at[32], at[79]); MULADD(at[33], at[78]); MULADD(at[34], at[77]); MULADD(at[35], at[76]); MULADD(at[36], at[75]); MULADD(at[37], at[74]); MULADD(at[38], at[73]); MULADD(at[39], at[72]); MULADD(at[40], at[71]); MULADD(at[41], at[70]); MULADD(at[42], at[69]); MULADD(at[43], at[68]); MULADD(at[44], at[67]); MULADD(at[45], at[66]); MULADD(at[46], at[65]); MULADD(at[47], at[64]); + COMBA_STORE(C->dp[63]); + /* 64 */ + COMBA_FORWARD; + MULADD(at[17], at[95]); MULADD(at[18], at[94]); MULADD(at[19], at[93]); MULADD(at[20], at[92]); MULADD(at[21], at[91]); MULADD(at[22], at[90]); MULADD(at[23], at[89]); MULADD(at[24], at[88]); MULADD(at[25], at[87]); MULADD(at[26], at[86]); MULADD(at[27], at[85]); MULADD(at[28], at[84]); MULADD(at[29], at[83]); MULADD(at[30], at[82]); MULADD(at[31], at[81]); MULADD(at[32], at[80]); MULADD(at[33], at[79]); MULADD(at[34], at[78]); MULADD(at[35], at[77]); MULADD(at[36], at[76]); MULADD(at[37], at[75]); MULADD(at[38], at[74]); MULADD(at[39], at[73]); MULADD(at[40], at[72]); MULADD(at[41], at[71]); MULADD(at[42], at[70]); MULADD(at[43], at[69]); MULADD(at[44], at[68]); MULADD(at[45], at[67]); MULADD(at[46], at[66]); MULADD(at[47], at[65]); + COMBA_STORE(C->dp[64]); + /* 65 */ + COMBA_FORWARD; + MULADD(at[18], at[95]); MULADD(at[19], at[94]); MULADD(at[20], at[93]); MULADD(at[21], at[92]); MULADD(at[22], at[91]); MULADD(at[23], at[90]); MULADD(at[24], at[89]); MULADD(at[25], at[88]); MULADD(at[26], at[87]); MULADD(at[27], at[86]); MULADD(at[28], at[85]); MULADD(at[29], at[84]); MULADD(at[30], at[83]); MULADD(at[31], at[82]); MULADD(at[32], at[81]); MULADD(at[33], at[80]); MULADD(at[34], at[79]); MULADD(at[35], at[78]); MULADD(at[36], at[77]); MULADD(at[37], at[76]); MULADD(at[38], at[75]); MULADD(at[39], at[74]); MULADD(at[40], at[73]); MULADD(at[41], at[72]); MULADD(at[42], at[71]); MULADD(at[43], at[70]); MULADD(at[44], at[69]); MULADD(at[45], at[68]); MULADD(at[46], at[67]); MULADD(at[47], at[66]); + COMBA_STORE(C->dp[65]); + /* 66 */ + COMBA_FORWARD; + MULADD(at[19], at[95]); MULADD(at[20], at[94]); MULADD(at[21], at[93]); MULADD(at[22], at[92]); MULADD(at[23], at[91]); MULADD(at[24], at[90]); MULADD(at[25], at[89]); MULADD(at[26], at[88]); MULADD(at[27], at[87]); MULADD(at[28], at[86]); MULADD(at[29], at[85]); MULADD(at[30], at[84]); MULADD(at[31], at[83]); MULADD(at[32], at[82]); MULADD(at[33], at[81]); MULADD(at[34], at[80]); MULADD(at[35], at[79]); MULADD(at[36], at[78]); MULADD(at[37], at[77]); MULADD(at[38], at[76]); MULADD(at[39], at[75]); MULADD(at[40], at[74]); MULADD(at[41], at[73]); MULADD(at[42], at[72]); MULADD(at[43], at[71]); MULADD(at[44], at[70]); MULADD(at[45], at[69]); MULADD(at[46], at[68]); MULADD(at[47], at[67]); + COMBA_STORE(C->dp[66]); + /* 67 */ + COMBA_FORWARD; + MULADD(at[20], at[95]); MULADD(at[21], at[94]); MULADD(at[22], at[93]); MULADD(at[23], at[92]); MULADD(at[24], at[91]); MULADD(at[25], at[90]); MULADD(at[26], at[89]); MULADD(at[27], at[88]); MULADD(at[28], at[87]); MULADD(at[29], at[86]); MULADD(at[30], at[85]); MULADD(at[31], at[84]); MULADD(at[32], at[83]); MULADD(at[33], at[82]); MULADD(at[34], at[81]); MULADD(at[35], at[80]); MULADD(at[36], at[79]); MULADD(at[37], at[78]); MULADD(at[38], at[77]); MULADD(at[39], at[76]); MULADD(at[40], at[75]); MULADD(at[41], at[74]); MULADD(at[42], at[73]); MULADD(at[43], at[72]); MULADD(at[44], at[71]); MULADD(at[45], at[70]); MULADD(at[46], at[69]); MULADD(at[47], at[68]); + COMBA_STORE(C->dp[67]); + /* 68 */ + COMBA_FORWARD; + MULADD(at[21], at[95]); MULADD(at[22], at[94]); MULADD(at[23], at[93]); MULADD(at[24], at[92]); MULADD(at[25], at[91]); MULADD(at[26], at[90]); MULADD(at[27], at[89]); MULADD(at[28], at[88]); MULADD(at[29], at[87]); MULADD(at[30], at[86]); MULADD(at[31], at[85]); MULADD(at[32], at[84]); MULADD(at[33], at[83]); MULADD(at[34], at[82]); MULADD(at[35], at[81]); MULADD(at[36], at[80]); MULADD(at[37], at[79]); MULADD(at[38], at[78]); MULADD(at[39], at[77]); MULADD(at[40], at[76]); MULADD(at[41], at[75]); MULADD(at[42], at[74]); MULADD(at[43], at[73]); MULADD(at[44], at[72]); MULADD(at[45], at[71]); MULADD(at[46], at[70]); MULADD(at[47], at[69]); + COMBA_STORE(C->dp[68]); + /* 69 */ + COMBA_FORWARD; + MULADD(at[22], at[95]); MULADD(at[23], at[94]); MULADD(at[24], at[93]); MULADD(at[25], at[92]); MULADD(at[26], at[91]); MULADD(at[27], at[90]); MULADD(at[28], at[89]); MULADD(at[29], at[88]); MULADD(at[30], at[87]); MULADD(at[31], at[86]); MULADD(at[32], at[85]); MULADD(at[33], at[84]); MULADD(at[34], at[83]); MULADD(at[35], at[82]); MULADD(at[36], at[81]); MULADD(at[37], at[80]); MULADD(at[38], at[79]); MULADD(at[39], at[78]); MULADD(at[40], at[77]); MULADD(at[41], at[76]); MULADD(at[42], at[75]); MULADD(at[43], at[74]); MULADD(at[44], at[73]); MULADD(at[45], at[72]); MULADD(at[46], at[71]); MULADD(at[47], at[70]); + COMBA_STORE(C->dp[69]); + /* 70 */ + COMBA_FORWARD; + MULADD(at[23], at[95]); MULADD(at[24], at[94]); MULADD(at[25], at[93]); MULADD(at[26], at[92]); MULADD(at[27], at[91]); MULADD(at[28], at[90]); MULADD(at[29], at[89]); MULADD(at[30], at[88]); MULADD(at[31], at[87]); MULADD(at[32], at[86]); MULADD(at[33], at[85]); MULADD(at[34], at[84]); MULADD(at[35], at[83]); MULADD(at[36], at[82]); MULADD(at[37], at[81]); MULADD(at[38], at[80]); MULADD(at[39], at[79]); MULADD(at[40], at[78]); MULADD(at[41], at[77]); MULADD(at[42], at[76]); MULADD(at[43], at[75]); MULADD(at[44], at[74]); MULADD(at[45], at[73]); MULADD(at[46], at[72]); MULADD(at[47], at[71]); + COMBA_STORE(C->dp[70]); + /* 71 */ + COMBA_FORWARD; + MULADD(at[24], at[95]); MULADD(at[25], at[94]); MULADD(at[26], at[93]); MULADD(at[27], at[92]); MULADD(at[28], at[91]); MULADD(at[29], at[90]); MULADD(at[30], at[89]); MULADD(at[31], at[88]); MULADD(at[32], at[87]); MULADD(at[33], at[86]); MULADD(at[34], at[85]); MULADD(at[35], at[84]); MULADD(at[36], at[83]); MULADD(at[37], at[82]); MULADD(at[38], at[81]); MULADD(at[39], at[80]); MULADD(at[40], at[79]); MULADD(at[41], at[78]); MULADD(at[42], at[77]); MULADD(at[43], at[76]); MULADD(at[44], at[75]); MULADD(at[45], at[74]); MULADD(at[46], at[73]); MULADD(at[47], at[72]); + COMBA_STORE(C->dp[71]); + /* 72 */ + COMBA_FORWARD; + MULADD(at[25], at[95]); MULADD(at[26], at[94]); MULADD(at[27], at[93]); MULADD(at[28], at[92]); MULADD(at[29], at[91]); MULADD(at[30], at[90]); MULADD(at[31], at[89]); MULADD(at[32], at[88]); MULADD(at[33], at[87]); MULADD(at[34], at[86]); MULADD(at[35], at[85]); MULADD(at[36], at[84]); MULADD(at[37], at[83]); MULADD(at[38], at[82]); MULADD(at[39], at[81]); MULADD(at[40], at[80]); MULADD(at[41], at[79]); MULADD(at[42], at[78]); MULADD(at[43], at[77]); MULADD(at[44], at[76]); MULADD(at[45], at[75]); MULADD(at[46], at[74]); MULADD(at[47], at[73]); + COMBA_STORE(C->dp[72]); + /* 73 */ + COMBA_FORWARD; + MULADD(at[26], at[95]); MULADD(at[27], at[94]); MULADD(at[28], at[93]); MULADD(at[29], at[92]); MULADD(at[30], at[91]); MULADD(at[31], at[90]); MULADD(at[32], at[89]); MULADD(at[33], at[88]); MULADD(at[34], at[87]); MULADD(at[35], at[86]); MULADD(at[36], at[85]); MULADD(at[37], at[84]); MULADD(at[38], at[83]); MULADD(at[39], at[82]); MULADD(at[40], at[81]); MULADD(at[41], at[80]); MULADD(at[42], at[79]); MULADD(at[43], at[78]); MULADD(at[44], at[77]); MULADD(at[45], at[76]); MULADD(at[46], at[75]); MULADD(at[47], at[74]); + COMBA_STORE(C->dp[73]); + /* 74 */ + COMBA_FORWARD; + MULADD(at[27], at[95]); MULADD(at[28], at[94]); MULADD(at[29], at[93]); MULADD(at[30], at[92]); MULADD(at[31], at[91]); MULADD(at[32], at[90]); MULADD(at[33], at[89]); MULADD(at[34], at[88]); MULADD(at[35], at[87]); MULADD(at[36], at[86]); MULADD(at[37], at[85]); MULADD(at[38], at[84]); MULADD(at[39], at[83]); MULADD(at[40], at[82]); MULADD(at[41], at[81]); MULADD(at[42], at[80]); MULADD(at[43], at[79]); MULADD(at[44], at[78]); MULADD(at[45], at[77]); MULADD(at[46], at[76]); MULADD(at[47], at[75]); + COMBA_STORE(C->dp[74]); + /* 75 */ + COMBA_FORWARD; + MULADD(at[28], at[95]); MULADD(at[29], at[94]); MULADD(at[30], at[93]); MULADD(at[31], at[92]); MULADD(at[32], at[91]); MULADD(at[33], at[90]); MULADD(at[34], at[89]); MULADD(at[35], at[88]); MULADD(at[36], at[87]); MULADD(at[37], at[86]); MULADD(at[38], at[85]); MULADD(at[39], at[84]); MULADD(at[40], at[83]); MULADD(at[41], at[82]); MULADD(at[42], at[81]); MULADD(at[43], at[80]); MULADD(at[44], at[79]); MULADD(at[45], at[78]); MULADD(at[46], at[77]); MULADD(at[47], at[76]); + COMBA_STORE(C->dp[75]); + /* 76 */ + COMBA_FORWARD; + MULADD(at[29], at[95]); MULADD(at[30], at[94]); MULADD(at[31], at[93]); MULADD(at[32], at[92]); MULADD(at[33], at[91]); MULADD(at[34], at[90]); MULADD(at[35], at[89]); MULADD(at[36], at[88]); MULADD(at[37], at[87]); MULADD(at[38], at[86]); MULADD(at[39], at[85]); MULADD(at[40], at[84]); MULADD(at[41], at[83]); MULADD(at[42], at[82]); MULADD(at[43], at[81]); MULADD(at[44], at[80]); MULADD(at[45], at[79]); MULADD(at[46], at[78]); MULADD(at[47], at[77]); + COMBA_STORE(C->dp[76]); + /* 77 */ + COMBA_FORWARD; + MULADD(at[30], at[95]); MULADD(at[31], at[94]); MULADD(at[32], at[93]); MULADD(at[33], at[92]); MULADD(at[34], at[91]); MULADD(at[35], at[90]); MULADD(at[36], at[89]); MULADD(at[37], at[88]); MULADD(at[38], at[87]); MULADD(at[39], at[86]); MULADD(at[40], at[85]); MULADD(at[41], at[84]); MULADD(at[42], at[83]); MULADD(at[43], at[82]); MULADD(at[44], at[81]); MULADD(at[45], at[80]); MULADD(at[46], at[79]); MULADD(at[47], at[78]); + COMBA_STORE(C->dp[77]); + /* 78 */ + COMBA_FORWARD; + MULADD(at[31], at[95]); MULADD(at[32], at[94]); MULADD(at[33], at[93]); MULADD(at[34], at[92]); MULADD(at[35], at[91]); MULADD(at[36], at[90]); MULADD(at[37], at[89]); MULADD(at[38], at[88]); MULADD(at[39], at[87]); MULADD(at[40], at[86]); MULADD(at[41], at[85]); MULADD(at[42], at[84]); MULADD(at[43], at[83]); MULADD(at[44], at[82]); MULADD(at[45], at[81]); MULADD(at[46], at[80]); MULADD(at[47], at[79]); + COMBA_STORE(C->dp[78]); + /* 79 */ + COMBA_FORWARD; + MULADD(at[32], at[95]); MULADD(at[33], at[94]); MULADD(at[34], at[93]); MULADD(at[35], at[92]); MULADD(at[36], at[91]); MULADD(at[37], at[90]); MULADD(at[38], at[89]); MULADD(at[39], at[88]); MULADD(at[40], at[87]); MULADD(at[41], at[86]); MULADD(at[42], at[85]); MULADD(at[43], at[84]); MULADD(at[44], at[83]); MULADD(at[45], at[82]); MULADD(at[46], at[81]); MULADD(at[47], at[80]); + COMBA_STORE(C->dp[79]); + /* 80 */ + COMBA_FORWARD; + MULADD(at[33], at[95]); MULADD(at[34], at[94]); MULADD(at[35], at[93]); MULADD(at[36], at[92]); MULADD(at[37], at[91]); MULADD(at[38], at[90]); MULADD(at[39], at[89]); MULADD(at[40], at[88]); MULADD(at[41], at[87]); MULADD(at[42], at[86]); MULADD(at[43], at[85]); MULADD(at[44], at[84]); MULADD(at[45], at[83]); MULADD(at[46], at[82]); MULADD(at[47], at[81]); + COMBA_STORE(C->dp[80]); + /* 81 */ + COMBA_FORWARD; + MULADD(at[34], at[95]); MULADD(at[35], at[94]); MULADD(at[36], at[93]); MULADD(at[37], at[92]); MULADD(at[38], at[91]); MULADD(at[39], at[90]); MULADD(at[40], at[89]); MULADD(at[41], at[88]); MULADD(at[42], at[87]); MULADD(at[43], at[86]); MULADD(at[44], at[85]); MULADD(at[45], at[84]); MULADD(at[46], at[83]); MULADD(at[47], at[82]); + COMBA_STORE(C->dp[81]); + /* 82 */ + COMBA_FORWARD; + MULADD(at[35], at[95]); MULADD(at[36], at[94]); MULADD(at[37], at[93]); MULADD(at[38], at[92]); MULADD(at[39], at[91]); MULADD(at[40], at[90]); MULADD(at[41], at[89]); MULADD(at[42], at[88]); MULADD(at[43], at[87]); MULADD(at[44], at[86]); MULADD(at[45], at[85]); MULADD(at[46], at[84]); MULADD(at[47], at[83]); + COMBA_STORE(C->dp[82]); + /* 83 */ + COMBA_FORWARD; + MULADD(at[36], at[95]); MULADD(at[37], at[94]); MULADD(at[38], at[93]); MULADD(at[39], at[92]); MULADD(at[40], at[91]); MULADD(at[41], at[90]); MULADD(at[42], at[89]); MULADD(at[43], at[88]); MULADD(at[44], at[87]); MULADD(at[45], at[86]); MULADD(at[46], at[85]); MULADD(at[47], at[84]); + COMBA_STORE(C->dp[83]); + /* 84 */ + COMBA_FORWARD; + MULADD(at[37], at[95]); MULADD(at[38], at[94]); MULADD(at[39], at[93]); MULADD(at[40], at[92]); MULADD(at[41], at[91]); MULADD(at[42], at[90]); MULADD(at[43], at[89]); MULADD(at[44], at[88]); MULADD(at[45], at[87]); MULADD(at[46], at[86]); MULADD(at[47], at[85]); + COMBA_STORE(C->dp[84]); + /* 85 */ + COMBA_FORWARD; + MULADD(at[38], at[95]); MULADD(at[39], at[94]); MULADD(at[40], at[93]); MULADD(at[41], at[92]); MULADD(at[42], at[91]); MULADD(at[43], at[90]); MULADD(at[44], at[89]); MULADD(at[45], at[88]); MULADD(at[46], at[87]); MULADD(at[47], at[86]); + COMBA_STORE(C->dp[85]); + /* 86 */ + COMBA_FORWARD; + MULADD(at[39], at[95]); MULADD(at[40], at[94]); MULADD(at[41], at[93]); MULADD(at[42], at[92]); MULADD(at[43], at[91]); MULADD(at[44], at[90]); MULADD(at[45], at[89]); MULADD(at[46], at[88]); MULADD(at[47], at[87]); + COMBA_STORE(C->dp[86]); + /* 87 */ + COMBA_FORWARD; + MULADD(at[40], at[95]); MULADD(at[41], at[94]); MULADD(at[42], at[93]); MULADD(at[43], at[92]); MULADD(at[44], at[91]); MULADD(at[45], at[90]); MULADD(at[46], at[89]); MULADD(at[47], at[88]); + COMBA_STORE(C->dp[87]); + /* 88 */ + COMBA_FORWARD; + MULADD(at[41], at[95]); MULADD(at[42], at[94]); MULADD(at[43], at[93]); MULADD(at[44], at[92]); MULADD(at[45], at[91]); MULADD(at[46], at[90]); MULADD(at[47], at[89]); + COMBA_STORE(C->dp[88]); + /* 89 */ + COMBA_FORWARD; + MULADD(at[42], at[95]); MULADD(at[43], at[94]); MULADD(at[44], at[93]); MULADD(at[45], at[92]); MULADD(at[46], at[91]); MULADD(at[47], at[90]); + COMBA_STORE(C->dp[89]); + /* 90 */ + COMBA_FORWARD; + MULADD(at[43], at[95]); MULADD(at[44], at[94]); MULADD(at[45], at[93]); MULADD(at[46], at[92]); MULADD(at[47], at[91]); + COMBA_STORE(C->dp[90]); + /* 91 */ + COMBA_FORWARD; + MULADD(at[44], at[95]); MULADD(at[45], at[94]); MULADD(at[46], at[93]); MULADD(at[47], at[92]); + COMBA_STORE(C->dp[91]); + /* 92 */ + COMBA_FORWARD; + MULADD(at[45], at[95]); MULADD(at[46], at[94]); MULADD(at[47], at[93]); + COMBA_STORE(C->dp[92]); + /* 93 */ + COMBA_FORWARD; + MULADD(at[46], at[95]); MULADD(at[47], at[94]); + COMBA_STORE(C->dp[93]); + /* 94 */ + COMBA_FORWARD; + MULADD(at[47], at[95]); + COMBA_STORE(C->dp[94]); + COMBA_STORE2(C->dp[95]); + C->used = 96; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; +} + + #endif + + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mul_d.c b/fp_mul_d.c index dcf43d4..50b0a0a 100644 --- a/fp_mul_d.c +++ b/fp_mul_d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -34,3 +34,7 @@ void fp_mul_d(fp_int *a, fp_digit b, fp_int *c) fp_clamp(c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_mulmod.c b/fp_mulmod.c index c9d008a..0a86836 100644 --- a/fp_mulmod.c +++ b/fp_mulmod.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include /* d = a * b (mod c) */ @@ -16,3 +16,7 @@ int fp_mulmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) fp_mul(a, b, &tmp); return fp_mod(&tmp, c, d); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_prime_miller_rabin.c b/fp_prime_miller_rabin.c index 92c6dd2..9cb361f 100644 --- a/fp_prime_miller_rabin.c +++ b/fp_prime_miller_rabin.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -71,3 +71,7 @@ void fp_prime_miller_rabin (fp_int * a, fp_int * b, int *result) /* probably prime now */ *result = FP_YES; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_prime_random_ex.c b/fp_prime_random_ex.c index 45e494d..05fb49a 100644 --- a/fp_prime_random_ex.c +++ b/fp_prime_random_ex.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -95,3 +95,7 @@ error: free(tmp); return err; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_radix_size.c b/fp_radix_size.c index d632e97..0909fca 100644 --- a/fp_radix_size.c +++ b/fp_radix_size.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -47,3 +47,7 @@ int fp_radix_size(fp_int *a, int radix, int *size) return FP_OKAY; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_read_radix.c b/fp_read_radix.c index bcfa068..0a7371c 100644 --- a/fp_read_radix.c +++ b/fp_read_radix.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -64,3 +64,7 @@ int fp_read_radix(fp_int *a, char *str, int radix) } return FP_OKAY; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_read_signed_bin.c b/fp_read_signed_bin.c index 6721cf3..a324893 100644 --- a/fp_read_signed_bin.c +++ b/fp_read_signed_bin.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -21,3 +21,7 @@ void fp_read_signed_bin(fp_int *a, unsigned char *b, int c) a->sign = FP_NEG; } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_read_unsigned_bin.c b/fp_read_unsigned_bin.c index 5cab45e..070e420 100644 --- a/fp_read_unsigned_bin.c +++ b/fp_read_unsigned_bin.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -22,3 +22,7 @@ void fp_read_unsigned_bin(fp_int *a, unsigned char *b, int c) } fp_clamp (a); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_reverse.c b/fp_reverse.c index de5ea41..f393579 100644 --- a/fp_reverse.c +++ b/fp_reverse.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -25,3 +25,7 @@ void bn_reverse (unsigned char *s, int len) --iy; } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_rshd.c b/fp_rshd.c index 225d1cd..2a72cf9 100644 --- a/fp_rshd.c +++ b/fp_rshd.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -34,3 +34,7 @@ void fp_rshd(fp_int *a, int x) fp_clamp(a); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_s_rmap.c b/fp_s_rmap.c index 53ac5b3..4f4a138 100644 --- a/fp_s_rmap.c +++ b/fp_s_rmap.c @@ -5,9 +5,13 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include /* chars used in radix conversions */ const char *fp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"; + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_set.c b/fp_set.c index 01428b5..e8c849b 100644 --- a/fp_set.c +++ b/fp_set.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -15,3 +15,7 @@ void fp_set(fp_int *a, fp_digit b) a->dp[0] = b; a->used = b ? 1 : 0; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_signed_bin_size.c b/fp_signed_bin_size.c index 016163f..be6661b 100644 --- a/fp_signed_bin_size.c +++ b/fp_signed_bin_size.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -13,3 +13,7 @@ int fp_signed_bin_size(fp_int *a) { return 1 + fp_unsigned_bin_size (a); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_sqr.c b/fp_sqr.c index d028a88..da3c944 100644 --- a/fp_sqr.c +++ b/fp_sqr.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -17,21 +17,26 @@ void fp_sqr(fp_int *A, fp_int *B) y = A->used; if (y <= 64) { - if (y <= 4) { - fp_sqr_comba4(A,B); - } else if (y <= 8) { - fp_sqr_comba8(A,B); -#if defined(TFM_LARGE) - } else if (y <= 16 && y >= 12) { - fp_sqr_comba16(A,B); + +#if defined(TFM_SMALL_SET) + if (y <= 16) { + fp_sqr_comba_small(A,B); +#elif defined(TFM_HUGE) + if (0) { 1; #endif #if defined(TFM_HUGE) - } else if (y <= 32 && y >= 20) { + } else if (y <= 32) { fp_sqr_comba32(A,B); - } else if (y <= 64 && y >= 48) { + } else if (y <= 48) { + fp_sqr_comba48(A,B); + } else if (y <= 64) { fp_sqr_comba64(A,B); #endif +#if !defined(TFM_SMALL_SET) && !defined(TFM_HUGE) + { +#else } else { +#endif fp_sqr_comba(A, B); } @@ -109,3 +114,7 @@ Obvious points of optimization } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_sqr_comba.c b/fp_sqr_comba.c index cdee78a..9b72493 100644 --- a/fp_sqr_comba.c +++ b/fp_sqr_comba.c @@ -5,12 +5,15 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include -/* About this file... -*/ +#if defined(TFM_PRESCOTT) && defined(TFM_SSE2) + #undef TFM_SSE2 + #define TFM_X86 +#endif + #if defined(TFM_X86) @@ -73,13 +76,13 @@ asm ( \ #define SQRADDDB \ asm ( \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - :"=r"(c0), "=r"(c1), "=r"(c2), "=g"(sc0), "=g"(sc1), "=g"(sc2) : "0"(c0), "1"(c1), "2"(c2), "3"(sc0), "4"(sc1), "5"(sc2) : "%cc"); + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "%cc"); #elif defined(TFM_X86_64) /* x86-64 optimized */ @@ -139,15 +142,15 @@ asm ( \ "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 \ +#define SQRADDDB \ asm ( \ - "addq %3,%0 \n\t" \ - "adcq %4,%1 \n\t" \ - "adcq %5,%2 \n\t" \ - "addq %3,%0 \n\t" \ - "adcq %4,%1 \n\t" \ - "adcq %5,%2 \n\t" \ - :"=r"(c0), "=r"(c1), "=r"(c2), "=r"(sc0), "=r"(sc1), "=r"(sc2) : "0"(c0), "1"(c1), "2"(c2), "3"(sc0), "4"(sc1), "5"(sc2) : "%cc"); + "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"); #elif defined(TFM_SSE2) @@ -200,14 +203,13 @@ asm volatile ( \ #define SQRADDSC(i, j) \ asm volatile ( \ "movd %6,%%mm0 \n\t" \ - "pmuludq %%mm0,%%mm0\n\t" \ - "movd %%mm0,%%eax \n\t" \ + "movd %7,%%mm1 \n\t" \ + "pmuludq %%mm1,%%mm0\n\t" \ + "movd %%mm0,%0 \n\t" \ "psrlq $32,%%mm0 \n\t" \ - "movl %%eax,%0 \n\t" \ - "movd %%mm0,%%eax \n\t" \ - "movl %%eax,%1 \n\t" \ + "movd %%mm0,%1 \n\t" \ "xorl %2,%2 \n\t" \ - :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i) :"%eax","%cc"); + :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i), "m"(j)); #define SQRADDAC(i, j) \ asm volatile ( \ @@ -220,20 +222,17 @@ asm volatile ( \ "addl %%eax,%0 \n\t" \ "adcl %%edx,%1 \n\t" \ "adcl $0,%2 \n\t" \ - "addl %%eax,%0 \n\t" \ - "adcl %%edx,%1 \n\t" \ - "adcl $0,%2 \n\t" \ :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i), "m"(j) :"%eax","%edx","%cc"); -#define SQRADDDB \ +#define SQRADDDB \ asm ( \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - :"=r"(c0), "=r"(c1), "=r"(c2), "=g"(sc0), "=g"(sc1), "=g"(sc2) : "0"(c0), "1"(c1), "2"(c2), "3"(sc0), "4"(sc1), "5"(sc2) : "%cc"); + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "%cc"); #elif defined(TFM_ARM) @@ -292,13 +291,82 @@ asm( \ #define SQRADDDB \ asm( \ -" ADDS %3,%0 \n\t" \ -" ADCS %4,%1 \n\t" \ -" ADC %5,%2 \n\t" \ -" ADDS %3,%0 \n\t" \ -" ADCS %4,%1 \n\t" \ -" ADC %5,%2 \n\t" \ -:"=r"(sc0), "=r"(sc1), "=r"(sc2), "=r"(c0), "=r"(c1), "=r"(c2) : "0"(sc0), "1"(sc1), "2"(sc2), "3"(c0), "4"(c1), "5"(c2) : "%cc"); +" ADDS %0,%0,%3 \n\t" \ +" ADCS %1,%1,%4 \n\t" \ +" ADC %2,%2,%5 \n\t" \ +" ADDS %0,%0,%3 \n\t" \ +" ADCS %1,%1,%4 \n\t" \ +" ADC %2,%2,%5 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc"); + +#elif defined(TFM_PPC32) + +/* PPC32 */ + +#define COMBA_START \ + +#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 \ + +/* multiplies point i and j, updates carry "c1" and digit c2 */ +#define SQRADD(i, j) \ +asm( \ + " mullw r16,%6,%6 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " mulhwu r16,%6,%6 \n\t" \ + " adde %1,%1,r16 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"r16","%cc"); + +/* for squaring some of the terms are doubled... */ +#define SQRADD2(i, j) \ +asm( \ + " mullw r16,%6,%7 \n\t" \ + " mulhwu r17,%6,%7 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " adde %1,%1,r17 \n\t" \ + " addze %2,%2 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " adde %1,%1,r17 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r16", "r17","%cc"); + +#define SQRADDSC(i, j) \ +asm( \ + " mullw %0,%6,%7 \n\t" \ + " mulhwu %1,%6,%7 \n\t" \ + " xor %2,%2,%2 \n\t" \ +:"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "%cc"); + +#define SQRADDAC(i, j) \ +asm( \ + " mullw r16,%6,%7 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " mulhwu r16,%6,%7 \n\t" \ + " adde %1,%1,r16 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"r16", "%cc"); + +#define SQRADDDB \ +asm( \ + " addc %0,%0,%3 \n\t" \ + " adde %1,%1,%4 \n\t" \ + " adde %2,%2,%5 \n\t" \ + " addc %0,%0,%3 \n\t" \ + " adde %1,%1,%4 \n\t" \ + " adde %2,%2,%5 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc"); #else @@ -362,327 +430,1521 @@ asm( \ #endif #include "fp_sqr_comba_generic.c" -void fp_sqr_comba4(fp_int *A, fp_int *B) -{ - fp_digit *a, b[8], 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[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 = FP_ZPOS; - memcpy(B->dp, b, 8 * sizeof(fp_digit)); - fp_clamp(B); -} - - -void fp_sqr_comba8(fp_int *A, fp_int *B) -{ - fp_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 = FP_ZPOS; - memcpy(B->dp, b, 16 * sizeof(fp_digit)); - fp_clamp(B); -} - - -#ifdef TFM_LARGE -void fp_sqr_comba16(fp_int *A, fp_int *B) +#if defined(TFM_SMALL_SET) +void fp_sqr_comba_small(fp_int *A, fp_int *B) { fp_digit *a, b[32], c0, c1, c2, sc0, sc1, sc2; + switch (A->used) { + case 1: + a = A->dp; + COMBA_START; - a = A->dp; - COMBA_START; + /* clear carries */ + CLEAR_CARRY; - /* clear carries */ - CLEAR_CARRY; + /* output 0 */ + SQRADD(a[0],a[0]); + COMBA_STORE(b[0]); + COMBA_STORE2(b[1]); + COMBA_FINI; - /* output 0 */ - SQRADD(a[0],a[0]); - COMBA_STORE(b[0]); + B->used = 2; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 2 * sizeof(fp_digit)); + fp_clamp(B); + break; - /* output 1 */ - CARRY_FORWARD; - SQRADD2(a[0], a[1]); - COMBA_STORE(b[1]); + case 2: + a = A->dp; + COMBA_START; - /* output 2 */ - CARRY_FORWARD; - SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]); - COMBA_STORE(b[2]); + /* clear carries */ + CLEAR_CARRY; - /* output 3 */ - CARRY_FORWARD; - SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]); - COMBA_STORE(b[3]); + /* output 0 */ + SQRADD(a[0],a[0]); + COMBA_STORE(b[0]); - /* output 4 */ - CARRY_FORWARD; - SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]); - COMBA_STORE(b[4]); + /* output 1 */ + CARRY_FORWARD; + SQRADD2(a[0], a[1]); + COMBA_STORE(b[1]); - /* output 5 */ - CARRY_FORWARD; + /* output 2 */ + CARRY_FORWARD; + SQRADD(a[1], a[1]); + COMBA_STORE(b[2]); + COMBA_STORE2(b[3]); + COMBA_FINI; + + B->used = 4; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 4 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 3: + 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[1], a[2]); + COMBA_STORE(b[3]); + + /* output 4 */ + CARRY_FORWARD; + SQRADD(a[2], a[2]); + COMBA_STORE(b[4]); + COMBA_STORE2(b[5]); + COMBA_FINI; + + B->used = 6; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 6 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 4: + 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 = FP_ZPOS; + memcpy(B->dp, b, 8 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 5: + 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; + SQRADD2(a[1], a[4]); SQRADD2(a[2], a[3]); + COMBA_STORE(b[5]); + + /* output 6 */ + CARRY_FORWARD; + SQRADD2(a[2], a[4]); SQRADD(a[3], a[3]); + COMBA_STORE(b[6]); + + /* output 7 */ + CARRY_FORWARD; + SQRADD2(a[3], a[4]); + COMBA_STORE(b[7]); + + /* output 8 */ + CARRY_FORWARD; + SQRADD(a[4], a[4]); + COMBA_STORE(b[8]); + COMBA_STORE2(b[9]); + COMBA_FINI; + + B->used = 10; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 10 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 6: + 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]); + COMBA_STORE(b[5]); - /* output 6 */ - CARRY_FORWARD; + /* output 6 */ + CARRY_FORWARD; + SQRADD2(a[1], a[5]); SQRADD2(a[2], a[4]); SQRADD(a[3], a[3]); + COMBA_STORE(b[6]); + + /* output 7 */ + CARRY_FORWARD; + SQRADD2(a[2], a[5]); SQRADD2(a[3], a[4]); + COMBA_STORE(b[7]); + + /* output 8 */ + CARRY_FORWARD; + SQRADD2(a[3], a[5]); SQRADD(a[4], a[4]); + COMBA_STORE(b[8]); + + /* output 9 */ + CARRY_FORWARD; + SQRADD2(a[4], a[5]); + COMBA_STORE(b[9]); + + /* output 10 */ + CARRY_FORWARD; + SQRADD(a[5], a[5]); + COMBA_STORE(b[10]); + COMBA_STORE2(b[11]); + COMBA_FINI; + + B->used = 12; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 12 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 7: + 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]); + COMBA_STORE(b[6]); - /* output 7 */ - CARRY_FORWARD; + /* output 7 */ + CARRY_FORWARD; + SQRADDSC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB; + COMBA_STORE(b[7]); + + /* output 8 */ + CARRY_FORWARD; + SQRADD2(a[2], a[6]); SQRADD2(a[3], a[5]); SQRADD(a[4], a[4]); + COMBA_STORE(b[8]); + + /* output 9 */ + CARRY_FORWARD; + SQRADD2(a[3], a[6]); SQRADD2(a[4], a[5]); + COMBA_STORE(b[9]); + + /* output 10 */ + CARRY_FORWARD; + SQRADD2(a[4], a[6]); SQRADD(a[5], a[5]); + COMBA_STORE(b[10]); + + /* output 11 */ + CARRY_FORWARD; + SQRADD2(a[5], a[6]); + COMBA_STORE(b[11]); + + /* output 12 */ + CARRY_FORWARD; + SQRADD(a[6], a[6]); + COMBA_STORE(b[12]); + COMBA_STORE2(b[13]); + COMBA_FINI; + + B->used = 14; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 14 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 8: + 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]); + COMBA_STORE(b[7]); - /* output 8 */ - CARRY_FORWARD; + /* 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 = FP_ZPOS; + memcpy(B->dp, b, 16 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 9: + 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]); + COMBA_STORE(b[8]); - /* output 9 */ - CARRY_FORWARD; + /* output 9 */ + CARRY_FORWARD; + SQRADDSC(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[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[3], a[8]); SQRADDAC(a[4], a[7]); SQRADDAC(a[5], a[6]); SQRADDDB; + COMBA_STORE(b[11]); + + /* output 12 */ + CARRY_FORWARD; + SQRADD2(a[4], a[8]); SQRADD2(a[5], a[7]); SQRADD(a[6], a[6]); + COMBA_STORE(b[12]); + + /* output 13 */ + CARRY_FORWARD; + SQRADD2(a[5], a[8]); SQRADD2(a[6], a[7]); + COMBA_STORE(b[13]); + + /* output 14 */ + CARRY_FORWARD; + SQRADD2(a[6], a[8]); SQRADD(a[7], a[7]); + COMBA_STORE(b[14]); + + /* output 15 */ + CARRY_FORWARD; + SQRADD2(a[7], a[8]); + COMBA_STORE(b[15]); + + /* output 16 */ + CARRY_FORWARD; + SQRADD(a[8], a[8]); + COMBA_STORE(b[16]); + COMBA_STORE2(b[17]); + COMBA_FINI; + + B->used = 18; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 18 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 10: + 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]); + COMBA_STORE(b[9]); - /* output 10 */ - CARRY_FORWARD; + /* output 10 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[4], a[9]); SQRADDAC(a[5], a[8]); SQRADDAC(a[6], a[7]); SQRADDDB; + COMBA_STORE(b[13]); + + /* output 14 */ + CARRY_FORWARD; + SQRADD2(a[5], a[9]); SQRADD2(a[6], a[8]); SQRADD(a[7], a[7]); + COMBA_STORE(b[14]); + + /* output 15 */ + CARRY_FORWARD; + SQRADD2(a[6], a[9]); SQRADD2(a[7], a[8]); + COMBA_STORE(b[15]); + + /* output 16 */ + CARRY_FORWARD; + SQRADD2(a[7], a[9]); SQRADD(a[8], a[8]); + COMBA_STORE(b[16]); + + /* output 17 */ + CARRY_FORWARD; + SQRADD2(a[8], a[9]); + COMBA_STORE(b[17]); + + /* output 18 */ + CARRY_FORWARD; + SQRADD(a[9], a[9]); + COMBA_STORE(b[18]); + COMBA_STORE2(b[19]); + COMBA_FINI; + + B->used = 20; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 20 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 11: + 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]); + COMBA_STORE(b[10]); - /* output 11 */ - CARRY_FORWARD; + /* output 11 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[5], a[10]); SQRADDAC(a[6], a[9]); SQRADDAC(a[7], a[8]); SQRADDDB; + COMBA_STORE(b[15]); + + /* output 16 */ + CARRY_FORWARD; + SQRADD2(a[6], a[10]); SQRADD2(a[7], a[9]); SQRADD(a[8], a[8]); + COMBA_STORE(b[16]); + + /* output 17 */ + CARRY_FORWARD; + SQRADD2(a[7], a[10]); SQRADD2(a[8], a[9]); + COMBA_STORE(b[17]); + + /* output 18 */ + CARRY_FORWARD; + SQRADD2(a[8], a[10]); SQRADD(a[9], a[9]); + COMBA_STORE(b[18]); + + /* output 19 */ + CARRY_FORWARD; + SQRADD2(a[9], a[10]); + COMBA_STORE(b[19]); + + /* output 20 */ + CARRY_FORWARD; + SQRADD(a[10], a[10]); + COMBA_STORE(b[20]); + COMBA_STORE2(b[21]); + COMBA_FINI; + + B->used = 22; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 22 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 12: + 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]); + COMBA_STORE(b[11]); - /* output 12 */ - CARRY_FORWARD; + /* output 12 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[6], a[11]); SQRADDAC(a[7], a[10]); SQRADDAC(a[8], a[9]); SQRADDDB; + COMBA_STORE(b[17]); + + /* output 18 */ + CARRY_FORWARD; + SQRADD2(a[7], a[11]); SQRADD2(a[8], a[10]); SQRADD(a[9], a[9]); + COMBA_STORE(b[18]); + + /* output 19 */ + CARRY_FORWARD; + SQRADD2(a[8], a[11]); SQRADD2(a[9], a[10]); + COMBA_STORE(b[19]); + + /* output 20 */ + CARRY_FORWARD; + SQRADD2(a[9], a[11]); SQRADD(a[10], a[10]); + COMBA_STORE(b[20]); + + /* output 21 */ + CARRY_FORWARD; + SQRADD2(a[10], a[11]); + COMBA_STORE(b[21]); + + /* output 22 */ + CARRY_FORWARD; + SQRADD(a[11], a[11]); + COMBA_STORE(b[22]); + COMBA_STORE2(b[23]); + COMBA_FINI; + + B->used = 24; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 24 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 13: + 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]); + COMBA_STORE(b[12]); - /* output 13 */ - CARRY_FORWARD; + /* output 13 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[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[7], a[12]); SQRADDAC(a[8], a[11]); SQRADDAC(a[9], a[10]); SQRADDDB; + COMBA_STORE(b[19]); + + /* output 20 */ + CARRY_FORWARD; + SQRADD2(a[8], a[12]); SQRADD2(a[9], a[11]); SQRADD(a[10], a[10]); + COMBA_STORE(b[20]); + + /* output 21 */ + CARRY_FORWARD; + SQRADD2(a[9], a[12]); SQRADD2(a[10], a[11]); + COMBA_STORE(b[21]); + + /* output 22 */ + CARRY_FORWARD; + SQRADD2(a[10], a[12]); SQRADD(a[11], a[11]); + COMBA_STORE(b[22]); + + /* output 23 */ + CARRY_FORWARD; + SQRADD2(a[11], a[12]); + COMBA_STORE(b[23]); + + /* output 24 */ + CARRY_FORWARD; + SQRADD(a[12], a[12]); + COMBA_STORE(b[24]); + COMBA_STORE2(b[25]); + COMBA_FINI; + + B->used = 26; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 26 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 14: + 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]); + COMBA_STORE(b[13]); - /* output 14 */ - CARRY_FORWARD; + /* output 14 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[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[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[8], a[13]); SQRADDAC(a[9], a[12]); SQRADDAC(a[10], a[11]); SQRADDDB; + COMBA_STORE(b[21]); + + /* output 22 */ + CARRY_FORWARD; + SQRADD2(a[9], a[13]); SQRADD2(a[10], a[12]); SQRADD(a[11], a[11]); + COMBA_STORE(b[22]); + + /* output 23 */ + CARRY_FORWARD; + SQRADD2(a[10], a[13]); SQRADD2(a[11], a[12]); + COMBA_STORE(b[23]); + + /* output 24 */ + CARRY_FORWARD; + SQRADD2(a[11], a[13]); SQRADD(a[12], a[12]); + COMBA_STORE(b[24]); + + /* output 25 */ + CARRY_FORWARD; + SQRADD2(a[12], a[13]); + COMBA_STORE(b[25]); + + /* output 26 */ + CARRY_FORWARD; + SQRADD(a[13], a[13]); + COMBA_STORE(b[26]); + COMBA_STORE2(b[27]); + COMBA_FINI; + + B->used = 28; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 28 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 15: + 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]); + COMBA_STORE(b[14]); - /* output 15 */ - CARRY_FORWARD; + /* output 15 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[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[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[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[9], a[14]); SQRADDAC(a[10], a[13]); SQRADDAC(a[11], a[12]); SQRADDDB; + COMBA_STORE(b[23]); + + /* output 24 */ + CARRY_FORWARD; + SQRADD2(a[10], a[14]); SQRADD2(a[11], a[13]); SQRADD(a[12], a[12]); + COMBA_STORE(b[24]); + + /* output 25 */ + CARRY_FORWARD; + SQRADD2(a[11], a[14]); SQRADD2(a[12], a[13]); + COMBA_STORE(b[25]); + + /* output 26 */ + CARRY_FORWARD; + SQRADD2(a[12], a[14]); SQRADD(a[13], a[13]); + COMBA_STORE(b[26]); + + /* output 27 */ + CARRY_FORWARD; + SQRADD2(a[13], a[14]); + COMBA_STORE(b[27]); + + /* output 28 */ + CARRY_FORWARD; + SQRADD(a[14], a[14]); + COMBA_STORE(b[28]); + COMBA_STORE2(b[29]); + COMBA_FINI; + + B->used = 30; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 30 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 16: + 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]); + COMBA_STORE(b[15]); - /* output 16 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[16]); - /* output 17 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[17]); - /* output 18 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[18]); - /* output 19 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[19]); - /* output 20 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[20]); - /* output 21 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[21]); - /* output 22 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[22]); - /* output 23 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[23]); - /* output 24 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[24]); - /* output 25 */ - CARRY_FORWARD; + /* output 25 */ + CARRY_FORWARD; SQRADDSC(a[10], a[15]); SQRADDAC(a[11], a[14]); SQRADDAC(a[12], a[13]); SQRADDDB; - COMBA_STORE(b[25]); + 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 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 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 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 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; + /* output 30 */ + CARRY_FORWARD; + SQRADD(a[15], a[15]); + COMBA_STORE(b[30]); + COMBA_STORE2(b[31]); + COMBA_FINI; - B->used = 32; - B->sign = FP_ZPOS; - memcpy(B->dp, b, 32 * sizeof(fp_digit)); - fp_clamp(B); + B->used = 32; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 32 * sizeof(fp_digit)); + fp_clamp(B); + break; +} } +#endif /* TFM_SMALL_SET */ + -#endif #ifdef TFM_HUGE void fp_sqr_comba32(fp_int *A, fp_int *B) { @@ -1672,5 +2934,502 @@ void fp_sqr_comba64(fp_int *A, fp_int *B) fp_clamp(B); } +void fp_sqr_comba48(fp_int *A, fp_int *B) +{ + fp_digit *a, b[96], 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[0], a[32]); SQRADDAC(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[0], a[33]); SQRADDAC(a[1], a[32]); SQRADDAC(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[0], a[34]); SQRADDAC(a[1], a[33]); SQRADDAC(a[2], a[32]); SQRADDAC(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[0], a[35]); SQRADDAC(a[1], a[34]); SQRADDAC(a[2], a[33]); SQRADDAC(a[3], a[32]); SQRADDAC(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[0], a[36]); SQRADDAC(a[1], a[35]); SQRADDAC(a[2], a[34]); SQRADDAC(a[3], a[33]); SQRADDAC(a[4], a[32]); SQRADDAC(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[0], a[37]); SQRADDAC(a[1], a[36]); SQRADDAC(a[2], a[35]); SQRADDAC(a[3], a[34]); SQRADDAC(a[4], a[33]); SQRADDAC(a[5], a[32]); SQRADDAC(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[0], a[38]); SQRADDAC(a[1], a[37]); SQRADDAC(a[2], a[36]); SQRADDAC(a[3], a[35]); SQRADDAC(a[4], a[34]); SQRADDAC(a[5], a[33]); SQRADDAC(a[6], a[32]); SQRADDAC(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[0], a[39]); SQRADDAC(a[1], a[38]); SQRADDAC(a[2], a[37]); SQRADDAC(a[3], a[36]); SQRADDAC(a[4], a[35]); SQRADDAC(a[5], a[34]); SQRADDAC(a[6], a[33]); SQRADDAC(a[7], a[32]); SQRADDAC(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[0], a[40]); SQRADDAC(a[1], a[39]); SQRADDAC(a[2], a[38]); SQRADDAC(a[3], a[37]); SQRADDAC(a[4], a[36]); SQRADDAC(a[5], a[35]); SQRADDAC(a[6], a[34]); SQRADDAC(a[7], a[33]); SQRADDAC(a[8], a[32]); SQRADDAC(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[0], a[41]); SQRADDAC(a[1], a[40]); SQRADDAC(a[2], a[39]); SQRADDAC(a[3], a[38]); SQRADDAC(a[4], a[37]); SQRADDAC(a[5], a[36]); SQRADDAC(a[6], a[35]); SQRADDAC(a[7], a[34]); SQRADDAC(a[8], a[33]); SQRADDAC(a[9], a[32]); SQRADDAC(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[0], a[42]); SQRADDAC(a[1], a[41]); SQRADDAC(a[2], a[40]); SQRADDAC(a[3], a[39]); SQRADDAC(a[4], a[38]); SQRADDAC(a[5], a[37]); SQRADDAC(a[6], a[36]); SQRADDAC(a[7], a[35]); SQRADDAC(a[8], a[34]); SQRADDAC(a[9], a[33]); SQRADDAC(a[10], a[32]); SQRADDAC(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[0], a[43]); SQRADDAC(a[1], a[42]); SQRADDAC(a[2], a[41]); SQRADDAC(a[3], a[40]); SQRADDAC(a[4], a[39]); SQRADDAC(a[5], a[38]); SQRADDAC(a[6], a[37]); SQRADDAC(a[7], a[36]); SQRADDAC(a[8], a[35]); SQRADDAC(a[9], a[34]); SQRADDAC(a[10], a[33]); SQRADDAC(a[11], a[32]); SQRADDAC(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[0], a[44]); SQRADDAC(a[1], a[43]); SQRADDAC(a[2], a[42]); SQRADDAC(a[3], a[41]); SQRADDAC(a[4], a[40]); SQRADDAC(a[5], a[39]); SQRADDAC(a[6], a[38]); SQRADDAC(a[7], a[37]); SQRADDAC(a[8], a[36]); SQRADDAC(a[9], a[35]); SQRADDAC(a[10], a[34]); SQRADDAC(a[11], a[33]); SQRADDAC(a[12], a[32]); SQRADDAC(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[0], a[45]); SQRADDAC(a[1], a[44]); SQRADDAC(a[2], a[43]); SQRADDAC(a[3], a[42]); SQRADDAC(a[4], a[41]); SQRADDAC(a[5], a[40]); SQRADDAC(a[6], a[39]); SQRADDAC(a[7], a[38]); SQRADDAC(a[8], a[37]); SQRADDAC(a[9], a[36]); SQRADDAC(a[10], a[35]); SQRADDAC(a[11], a[34]); SQRADDAC(a[12], a[33]); SQRADDAC(a[13], a[32]); SQRADDAC(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[0], a[46]); SQRADDAC(a[1], a[45]); SQRADDAC(a[2], a[44]); SQRADDAC(a[3], a[43]); SQRADDAC(a[4], a[42]); SQRADDAC(a[5], a[41]); SQRADDAC(a[6], a[40]); SQRADDAC(a[7], a[39]); SQRADDAC(a[8], a[38]); SQRADDAC(a[9], a[37]); SQRADDAC(a[10], a[36]); SQRADDAC(a[11], a[35]); SQRADDAC(a[12], a[34]); SQRADDAC(a[13], a[33]); SQRADDAC(a[14], a[32]); SQRADDAC(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[0], a[47]); SQRADDAC(a[1], a[46]); SQRADDAC(a[2], a[45]); SQRADDAC(a[3], a[44]); SQRADDAC(a[4], a[43]); SQRADDAC(a[5], a[42]); SQRADDAC(a[6], a[41]); SQRADDAC(a[7], a[40]); SQRADDAC(a[8], a[39]); SQRADDAC(a[9], a[38]); SQRADDAC(a[10], a[37]); SQRADDAC(a[11], a[36]); SQRADDAC(a[12], a[35]); SQRADDAC(a[13], a[34]); SQRADDAC(a[14], a[33]); SQRADDAC(a[15], a[32]); SQRADDAC(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[1], a[47]); SQRADDAC(a[2], a[46]); SQRADDAC(a[3], a[45]); SQRADDAC(a[4], a[44]); SQRADDAC(a[5], a[43]); SQRADDAC(a[6], a[42]); SQRADDAC(a[7], a[41]); SQRADDAC(a[8], a[40]); SQRADDAC(a[9], a[39]); SQRADDAC(a[10], a[38]); SQRADDAC(a[11], a[37]); SQRADDAC(a[12], a[36]); SQRADDAC(a[13], a[35]); SQRADDAC(a[14], a[34]); SQRADDAC(a[15], a[33]); SQRADDAC(a[16], a[32]); SQRADDAC(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[2], a[47]); SQRADDAC(a[3], a[46]); SQRADDAC(a[4], a[45]); SQRADDAC(a[5], a[44]); SQRADDAC(a[6], a[43]); SQRADDAC(a[7], a[42]); SQRADDAC(a[8], a[41]); SQRADDAC(a[9], a[40]); SQRADDAC(a[10], a[39]); SQRADDAC(a[11], a[38]); SQRADDAC(a[12], a[37]); SQRADDAC(a[13], a[36]); SQRADDAC(a[14], a[35]); SQRADDAC(a[15], a[34]); SQRADDAC(a[16], a[33]); SQRADDAC(a[17], a[32]); SQRADDAC(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[3], a[47]); SQRADDAC(a[4], a[46]); SQRADDAC(a[5], a[45]); SQRADDAC(a[6], a[44]); SQRADDAC(a[7], a[43]); SQRADDAC(a[8], a[42]); SQRADDAC(a[9], a[41]); SQRADDAC(a[10], a[40]); SQRADDAC(a[11], a[39]); SQRADDAC(a[12], a[38]); SQRADDAC(a[13], a[37]); SQRADDAC(a[14], a[36]); SQRADDAC(a[15], a[35]); SQRADDAC(a[16], a[34]); SQRADDAC(a[17], a[33]); SQRADDAC(a[18], a[32]); SQRADDAC(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[4], a[47]); SQRADDAC(a[5], a[46]); SQRADDAC(a[6], a[45]); SQRADDAC(a[7], a[44]); SQRADDAC(a[8], a[43]); SQRADDAC(a[9], a[42]); SQRADDAC(a[10], a[41]); SQRADDAC(a[11], a[40]); SQRADDAC(a[12], a[39]); SQRADDAC(a[13], a[38]); SQRADDAC(a[14], a[37]); SQRADDAC(a[15], a[36]); SQRADDAC(a[16], a[35]); SQRADDAC(a[17], a[34]); SQRADDAC(a[18], a[33]); SQRADDAC(a[19], a[32]); SQRADDAC(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[5], a[47]); SQRADDAC(a[6], a[46]); SQRADDAC(a[7], a[45]); SQRADDAC(a[8], a[44]); SQRADDAC(a[9], a[43]); SQRADDAC(a[10], a[42]); SQRADDAC(a[11], a[41]); SQRADDAC(a[12], a[40]); SQRADDAC(a[13], a[39]); SQRADDAC(a[14], a[38]); SQRADDAC(a[15], a[37]); SQRADDAC(a[16], a[36]); SQRADDAC(a[17], a[35]); SQRADDAC(a[18], a[34]); SQRADDAC(a[19], a[33]); SQRADDAC(a[20], a[32]); SQRADDAC(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[6], a[47]); SQRADDAC(a[7], a[46]); SQRADDAC(a[8], a[45]); SQRADDAC(a[9], a[44]); SQRADDAC(a[10], a[43]); SQRADDAC(a[11], a[42]); SQRADDAC(a[12], a[41]); SQRADDAC(a[13], a[40]); SQRADDAC(a[14], a[39]); SQRADDAC(a[15], a[38]); SQRADDAC(a[16], a[37]); SQRADDAC(a[17], a[36]); SQRADDAC(a[18], a[35]); SQRADDAC(a[19], a[34]); SQRADDAC(a[20], a[33]); SQRADDAC(a[21], a[32]); SQRADDAC(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[7], a[47]); SQRADDAC(a[8], a[46]); SQRADDAC(a[9], a[45]); SQRADDAC(a[10], a[44]); SQRADDAC(a[11], a[43]); SQRADDAC(a[12], a[42]); SQRADDAC(a[13], a[41]); SQRADDAC(a[14], a[40]); SQRADDAC(a[15], a[39]); SQRADDAC(a[16], a[38]); SQRADDAC(a[17], a[37]); SQRADDAC(a[18], a[36]); SQRADDAC(a[19], a[35]); SQRADDAC(a[20], a[34]); SQRADDAC(a[21], a[33]); SQRADDAC(a[22], a[32]); SQRADDAC(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[8], a[47]); SQRADDAC(a[9], a[46]); SQRADDAC(a[10], a[45]); SQRADDAC(a[11], a[44]); SQRADDAC(a[12], a[43]); SQRADDAC(a[13], a[42]); SQRADDAC(a[14], a[41]); SQRADDAC(a[15], a[40]); SQRADDAC(a[16], a[39]); SQRADDAC(a[17], a[38]); SQRADDAC(a[18], a[37]); SQRADDAC(a[19], a[36]); SQRADDAC(a[20], a[35]); SQRADDAC(a[21], a[34]); SQRADDAC(a[22], a[33]); SQRADDAC(a[23], a[32]); SQRADDAC(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[9], a[47]); SQRADDAC(a[10], a[46]); SQRADDAC(a[11], a[45]); SQRADDAC(a[12], a[44]); SQRADDAC(a[13], a[43]); SQRADDAC(a[14], a[42]); SQRADDAC(a[15], a[41]); SQRADDAC(a[16], a[40]); SQRADDAC(a[17], a[39]); SQRADDAC(a[18], a[38]); SQRADDAC(a[19], a[37]); SQRADDAC(a[20], a[36]); SQRADDAC(a[21], a[35]); SQRADDAC(a[22], a[34]); SQRADDAC(a[23], a[33]); SQRADDAC(a[24], a[32]); SQRADDAC(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[10], a[47]); SQRADDAC(a[11], a[46]); SQRADDAC(a[12], a[45]); SQRADDAC(a[13], a[44]); SQRADDAC(a[14], a[43]); SQRADDAC(a[15], a[42]); SQRADDAC(a[16], a[41]); SQRADDAC(a[17], a[40]); SQRADDAC(a[18], a[39]); SQRADDAC(a[19], a[38]); SQRADDAC(a[20], a[37]); SQRADDAC(a[21], a[36]); SQRADDAC(a[22], a[35]); SQRADDAC(a[23], a[34]); SQRADDAC(a[24], a[33]); SQRADDAC(a[25], a[32]); SQRADDAC(a[26], a[31]); SQRADDAC(a[27], a[30]); SQRADDAC(a[28], a[29]); SQRADDDB; + COMBA_STORE(b[57]); + + /* output 58 */ + CARRY_FORWARD; + SQRADDSC(a[11], a[47]); SQRADDAC(a[12], a[46]); SQRADDAC(a[13], a[45]); SQRADDAC(a[14], a[44]); SQRADDAC(a[15], a[43]); SQRADDAC(a[16], a[42]); SQRADDAC(a[17], a[41]); SQRADDAC(a[18], a[40]); SQRADDAC(a[19], a[39]); SQRADDAC(a[20], a[38]); SQRADDAC(a[21], a[37]); SQRADDAC(a[22], a[36]); SQRADDAC(a[23], a[35]); SQRADDAC(a[24], a[34]); SQRADDAC(a[25], a[33]); SQRADDAC(a[26], a[32]); SQRADDAC(a[27], a[31]); SQRADDAC(a[28], a[30]); SQRADDDB; SQRADD(a[29], a[29]); + COMBA_STORE(b[58]); + + /* output 59 */ + CARRY_FORWARD; + SQRADDSC(a[12], a[47]); SQRADDAC(a[13], a[46]); SQRADDAC(a[14], a[45]); SQRADDAC(a[15], a[44]); SQRADDAC(a[16], a[43]); SQRADDAC(a[17], a[42]); SQRADDAC(a[18], a[41]); SQRADDAC(a[19], a[40]); SQRADDAC(a[20], a[39]); SQRADDAC(a[21], a[38]); SQRADDAC(a[22], a[37]); SQRADDAC(a[23], a[36]); SQRADDAC(a[24], a[35]); SQRADDAC(a[25], a[34]); SQRADDAC(a[26], a[33]); SQRADDAC(a[27], a[32]); SQRADDAC(a[28], a[31]); SQRADDAC(a[29], a[30]); SQRADDDB; + COMBA_STORE(b[59]); + + /* output 60 */ + CARRY_FORWARD; + SQRADDSC(a[13], a[47]); SQRADDAC(a[14], a[46]); SQRADDAC(a[15], a[45]); SQRADDAC(a[16], a[44]); SQRADDAC(a[17], a[43]); SQRADDAC(a[18], a[42]); SQRADDAC(a[19], a[41]); SQRADDAC(a[20], a[40]); SQRADDAC(a[21], a[39]); SQRADDAC(a[22], a[38]); SQRADDAC(a[23], a[37]); SQRADDAC(a[24], a[36]); SQRADDAC(a[25], a[35]); SQRADDAC(a[26], a[34]); SQRADDAC(a[27], a[33]); SQRADDAC(a[28], a[32]); SQRADDAC(a[29], a[31]); SQRADDDB; SQRADD(a[30], a[30]); + COMBA_STORE(b[60]); + + /* output 61 */ + CARRY_FORWARD; + SQRADDSC(a[14], a[47]); SQRADDAC(a[15], a[46]); SQRADDAC(a[16], a[45]); SQRADDAC(a[17], a[44]); SQRADDAC(a[18], a[43]); SQRADDAC(a[19], a[42]); SQRADDAC(a[20], a[41]); SQRADDAC(a[21], a[40]); SQRADDAC(a[22], a[39]); SQRADDAC(a[23], a[38]); SQRADDAC(a[24], a[37]); SQRADDAC(a[25], a[36]); SQRADDAC(a[26], a[35]); SQRADDAC(a[27], a[34]); SQRADDAC(a[28], a[33]); SQRADDAC(a[29], a[32]); SQRADDAC(a[30], a[31]); SQRADDDB; + COMBA_STORE(b[61]); + + /* output 62 */ + CARRY_FORWARD; + SQRADDSC(a[15], a[47]); SQRADDAC(a[16], a[46]); SQRADDAC(a[17], a[45]); SQRADDAC(a[18], a[44]); SQRADDAC(a[19], a[43]); SQRADDAC(a[20], a[42]); SQRADDAC(a[21], a[41]); SQRADDAC(a[22], a[40]); SQRADDAC(a[23], a[39]); SQRADDAC(a[24], a[38]); SQRADDAC(a[25], a[37]); SQRADDAC(a[26], a[36]); SQRADDAC(a[27], a[35]); SQRADDAC(a[28], a[34]); SQRADDAC(a[29], a[33]); SQRADDAC(a[30], a[32]); SQRADDDB; SQRADD(a[31], a[31]); + COMBA_STORE(b[62]); + + /* output 63 */ + CARRY_FORWARD; + SQRADDSC(a[16], a[47]); SQRADDAC(a[17], a[46]); SQRADDAC(a[18], a[45]); SQRADDAC(a[19], a[44]); SQRADDAC(a[20], a[43]); SQRADDAC(a[21], a[42]); SQRADDAC(a[22], a[41]); SQRADDAC(a[23], a[40]); SQRADDAC(a[24], a[39]); SQRADDAC(a[25], a[38]); SQRADDAC(a[26], a[37]); SQRADDAC(a[27], a[36]); SQRADDAC(a[28], a[35]); SQRADDAC(a[29], a[34]); SQRADDAC(a[30], a[33]); SQRADDAC(a[31], a[32]); SQRADDDB; + COMBA_STORE(b[63]); + + /* output 64 */ + CARRY_FORWARD; + SQRADDSC(a[17], a[47]); SQRADDAC(a[18], a[46]); SQRADDAC(a[19], a[45]); SQRADDAC(a[20], a[44]); SQRADDAC(a[21], a[43]); SQRADDAC(a[22], a[42]); SQRADDAC(a[23], a[41]); SQRADDAC(a[24], a[40]); SQRADDAC(a[25], a[39]); SQRADDAC(a[26], a[38]); SQRADDAC(a[27], a[37]); SQRADDAC(a[28], a[36]); SQRADDAC(a[29], a[35]); SQRADDAC(a[30], a[34]); SQRADDAC(a[31], a[33]); SQRADDDB; SQRADD(a[32], a[32]); + COMBA_STORE(b[64]); + + /* output 65 */ + CARRY_FORWARD; + SQRADDSC(a[18], a[47]); SQRADDAC(a[19], a[46]); SQRADDAC(a[20], a[45]); SQRADDAC(a[21], a[44]); SQRADDAC(a[22], a[43]); SQRADDAC(a[23], a[42]); SQRADDAC(a[24], a[41]); SQRADDAC(a[25], a[40]); SQRADDAC(a[26], a[39]); SQRADDAC(a[27], a[38]); SQRADDAC(a[28], a[37]); SQRADDAC(a[29], a[36]); SQRADDAC(a[30], a[35]); SQRADDAC(a[31], a[34]); SQRADDAC(a[32], a[33]); SQRADDDB; + COMBA_STORE(b[65]); + + /* output 66 */ + CARRY_FORWARD; + SQRADDSC(a[19], a[47]); SQRADDAC(a[20], a[46]); SQRADDAC(a[21], a[45]); SQRADDAC(a[22], a[44]); SQRADDAC(a[23], a[43]); SQRADDAC(a[24], a[42]); SQRADDAC(a[25], a[41]); SQRADDAC(a[26], a[40]); SQRADDAC(a[27], a[39]); SQRADDAC(a[28], a[38]); SQRADDAC(a[29], a[37]); SQRADDAC(a[30], a[36]); SQRADDAC(a[31], a[35]); SQRADDAC(a[32], a[34]); SQRADDDB; SQRADD(a[33], a[33]); + COMBA_STORE(b[66]); + + /* output 67 */ + CARRY_FORWARD; + SQRADDSC(a[20], a[47]); SQRADDAC(a[21], a[46]); SQRADDAC(a[22], a[45]); SQRADDAC(a[23], a[44]); SQRADDAC(a[24], a[43]); SQRADDAC(a[25], a[42]); SQRADDAC(a[26], a[41]); SQRADDAC(a[27], a[40]); SQRADDAC(a[28], a[39]); SQRADDAC(a[29], a[38]); SQRADDAC(a[30], a[37]); SQRADDAC(a[31], a[36]); SQRADDAC(a[32], a[35]); SQRADDAC(a[33], a[34]); SQRADDDB; + COMBA_STORE(b[67]); + + /* output 68 */ + CARRY_FORWARD; + SQRADDSC(a[21], a[47]); SQRADDAC(a[22], a[46]); SQRADDAC(a[23], a[45]); SQRADDAC(a[24], a[44]); SQRADDAC(a[25], a[43]); SQRADDAC(a[26], a[42]); SQRADDAC(a[27], a[41]); SQRADDAC(a[28], a[40]); SQRADDAC(a[29], a[39]); SQRADDAC(a[30], a[38]); SQRADDAC(a[31], a[37]); SQRADDAC(a[32], a[36]); SQRADDAC(a[33], a[35]); SQRADDDB; SQRADD(a[34], a[34]); + COMBA_STORE(b[68]); + + /* output 69 */ + CARRY_FORWARD; + SQRADDSC(a[22], a[47]); SQRADDAC(a[23], a[46]); SQRADDAC(a[24], a[45]); SQRADDAC(a[25], a[44]); SQRADDAC(a[26], a[43]); SQRADDAC(a[27], a[42]); SQRADDAC(a[28], a[41]); SQRADDAC(a[29], a[40]); SQRADDAC(a[30], a[39]); SQRADDAC(a[31], a[38]); SQRADDAC(a[32], a[37]); SQRADDAC(a[33], a[36]); SQRADDAC(a[34], a[35]); SQRADDDB; + COMBA_STORE(b[69]); + + /* output 70 */ + CARRY_FORWARD; + SQRADDSC(a[23], a[47]); SQRADDAC(a[24], a[46]); SQRADDAC(a[25], a[45]); SQRADDAC(a[26], a[44]); SQRADDAC(a[27], a[43]); SQRADDAC(a[28], a[42]); SQRADDAC(a[29], a[41]); SQRADDAC(a[30], a[40]); SQRADDAC(a[31], a[39]); SQRADDAC(a[32], a[38]); SQRADDAC(a[33], a[37]); SQRADDAC(a[34], a[36]); SQRADDDB; SQRADD(a[35], a[35]); + COMBA_STORE(b[70]); + + /* output 71 */ + CARRY_FORWARD; + SQRADDSC(a[24], a[47]); SQRADDAC(a[25], a[46]); SQRADDAC(a[26], a[45]); SQRADDAC(a[27], a[44]); SQRADDAC(a[28], a[43]); SQRADDAC(a[29], a[42]); SQRADDAC(a[30], a[41]); SQRADDAC(a[31], a[40]); SQRADDAC(a[32], a[39]); SQRADDAC(a[33], a[38]); SQRADDAC(a[34], a[37]); SQRADDAC(a[35], a[36]); SQRADDDB; + COMBA_STORE(b[71]); + + /* output 72 */ + CARRY_FORWARD; + SQRADDSC(a[25], a[47]); SQRADDAC(a[26], a[46]); SQRADDAC(a[27], a[45]); SQRADDAC(a[28], a[44]); SQRADDAC(a[29], a[43]); SQRADDAC(a[30], a[42]); SQRADDAC(a[31], a[41]); SQRADDAC(a[32], a[40]); SQRADDAC(a[33], a[39]); SQRADDAC(a[34], a[38]); SQRADDAC(a[35], a[37]); SQRADDDB; SQRADD(a[36], a[36]); + COMBA_STORE(b[72]); + + /* output 73 */ + CARRY_FORWARD; + SQRADDSC(a[26], a[47]); SQRADDAC(a[27], a[46]); SQRADDAC(a[28], a[45]); SQRADDAC(a[29], a[44]); SQRADDAC(a[30], a[43]); SQRADDAC(a[31], a[42]); SQRADDAC(a[32], a[41]); SQRADDAC(a[33], a[40]); SQRADDAC(a[34], a[39]); SQRADDAC(a[35], a[38]); SQRADDAC(a[36], a[37]); SQRADDDB; + COMBA_STORE(b[73]); + + /* output 74 */ + CARRY_FORWARD; + SQRADDSC(a[27], a[47]); SQRADDAC(a[28], a[46]); SQRADDAC(a[29], a[45]); SQRADDAC(a[30], a[44]); SQRADDAC(a[31], a[43]); SQRADDAC(a[32], a[42]); SQRADDAC(a[33], a[41]); SQRADDAC(a[34], a[40]); SQRADDAC(a[35], a[39]); SQRADDAC(a[36], a[38]); SQRADDDB; SQRADD(a[37], a[37]); + COMBA_STORE(b[74]); + + /* output 75 */ + CARRY_FORWARD; + SQRADDSC(a[28], a[47]); SQRADDAC(a[29], a[46]); SQRADDAC(a[30], a[45]); SQRADDAC(a[31], a[44]); SQRADDAC(a[32], a[43]); SQRADDAC(a[33], a[42]); SQRADDAC(a[34], a[41]); SQRADDAC(a[35], a[40]); SQRADDAC(a[36], a[39]); SQRADDAC(a[37], a[38]); SQRADDDB; + COMBA_STORE(b[75]); + + /* output 76 */ + CARRY_FORWARD; + SQRADDSC(a[29], a[47]); SQRADDAC(a[30], a[46]); SQRADDAC(a[31], a[45]); SQRADDAC(a[32], a[44]); SQRADDAC(a[33], a[43]); SQRADDAC(a[34], a[42]); SQRADDAC(a[35], a[41]); SQRADDAC(a[36], a[40]); SQRADDAC(a[37], a[39]); SQRADDDB; SQRADD(a[38], a[38]); + COMBA_STORE(b[76]); + + /* output 77 */ + CARRY_FORWARD; + SQRADDSC(a[30], a[47]); SQRADDAC(a[31], a[46]); SQRADDAC(a[32], a[45]); SQRADDAC(a[33], a[44]); SQRADDAC(a[34], a[43]); SQRADDAC(a[35], a[42]); SQRADDAC(a[36], a[41]); SQRADDAC(a[37], a[40]); SQRADDAC(a[38], a[39]); SQRADDDB; + COMBA_STORE(b[77]); + + /* output 78 */ + CARRY_FORWARD; + SQRADDSC(a[31], a[47]); SQRADDAC(a[32], a[46]); SQRADDAC(a[33], a[45]); SQRADDAC(a[34], a[44]); SQRADDAC(a[35], a[43]); SQRADDAC(a[36], a[42]); SQRADDAC(a[37], a[41]); SQRADDAC(a[38], a[40]); SQRADDDB; SQRADD(a[39], a[39]); + COMBA_STORE(b[78]); + + /* output 79 */ + CARRY_FORWARD; + SQRADDSC(a[32], a[47]); SQRADDAC(a[33], a[46]); SQRADDAC(a[34], a[45]); SQRADDAC(a[35], a[44]); SQRADDAC(a[36], a[43]); SQRADDAC(a[37], a[42]); SQRADDAC(a[38], a[41]); SQRADDAC(a[39], a[40]); SQRADDDB; + COMBA_STORE(b[79]); + + /* output 80 */ + CARRY_FORWARD; + SQRADDSC(a[33], a[47]); SQRADDAC(a[34], a[46]); SQRADDAC(a[35], a[45]); SQRADDAC(a[36], a[44]); SQRADDAC(a[37], a[43]); SQRADDAC(a[38], a[42]); SQRADDAC(a[39], a[41]); SQRADDDB; SQRADD(a[40], a[40]); + COMBA_STORE(b[80]); + + /* output 81 */ + CARRY_FORWARD; + SQRADDSC(a[34], a[47]); SQRADDAC(a[35], a[46]); SQRADDAC(a[36], a[45]); SQRADDAC(a[37], a[44]); SQRADDAC(a[38], a[43]); SQRADDAC(a[39], a[42]); SQRADDAC(a[40], a[41]); SQRADDDB; + COMBA_STORE(b[81]); + + /* output 82 */ + CARRY_FORWARD; + SQRADDSC(a[35], a[47]); SQRADDAC(a[36], a[46]); SQRADDAC(a[37], a[45]); SQRADDAC(a[38], a[44]); SQRADDAC(a[39], a[43]); SQRADDAC(a[40], a[42]); SQRADDDB; SQRADD(a[41], a[41]); + COMBA_STORE(b[82]); + + /* output 83 */ + CARRY_FORWARD; + SQRADDSC(a[36], a[47]); SQRADDAC(a[37], a[46]); SQRADDAC(a[38], a[45]); SQRADDAC(a[39], a[44]); SQRADDAC(a[40], a[43]); SQRADDAC(a[41], a[42]); SQRADDDB; + COMBA_STORE(b[83]); + + /* output 84 */ + CARRY_FORWARD; + SQRADDSC(a[37], a[47]); SQRADDAC(a[38], a[46]); SQRADDAC(a[39], a[45]); SQRADDAC(a[40], a[44]); SQRADDAC(a[41], a[43]); SQRADDDB; SQRADD(a[42], a[42]); + COMBA_STORE(b[84]); + + /* output 85 */ + CARRY_FORWARD; + SQRADDSC(a[38], a[47]); SQRADDAC(a[39], a[46]); SQRADDAC(a[40], a[45]); SQRADDAC(a[41], a[44]); SQRADDAC(a[42], a[43]); SQRADDDB; + COMBA_STORE(b[85]); + + /* output 86 */ + CARRY_FORWARD; + SQRADDSC(a[39], a[47]); SQRADDAC(a[40], a[46]); SQRADDAC(a[41], a[45]); SQRADDAC(a[42], a[44]); SQRADDDB; SQRADD(a[43], a[43]); + COMBA_STORE(b[86]); + + /* output 87 */ + CARRY_FORWARD; + SQRADDSC(a[40], a[47]); SQRADDAC(a[41], a[46]); SQRADDAC(a[42], a[45]); SQRADDAC(a[43], a[44]); SQRADDDB; + COMBA_STORE(b[87]); + + /* output 88 */ + CARRY_FORWARD; + SQRADDSC(a[41], a[47]); SQRADDAC(a[42], a[46]); SQRADDAC(a[43], a[45]); SQRADDDB; SQRADD(a[44], a[44]); + COMBA_STORE(b[88]); + + /* output 89 */ + CARRY_FORWARD; + SQRADDSC(a[42], a[47]); SQRADDAC(a[43], a[46]); SQRADDAC(a[44], a[45]); SQRADDDB; + COMBA_STORE(b[89]); + + /* output 90 */ + CARRY_FORWARD; + SQRADD2(a[43], a[47]); SQRADD2(a[44], a[46]); SQRADD(a[45], a[45]); + COMBA_STORE(b[90]); + + /* output 91 */ + CARRY_FORWARD; + SQRADD2(a[44], a[47]); SQRADD2(a[45], a[46]); + COMBA_STORE(b[91]); + + /* output 92 */ + CARRY_FORWARD; + SQRADD2(a[45], a[47]); SQRADD(a[46], a[46]); + COMBA_STORE(b[92]); + + /* output 93 */ + CARRY_FORWARD; + SQRADD2(a[46], a[47]); + COMBA_STORE(b[93]); + + /* output 94 */ + CARRY_FORWARD; + SQRADD(a[47], a[47]); + COMBA_STORE(b[94]); + COMBA_STORE2(b[95]); + COMBA_FINI; + + B->used = 96; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 96 * sizeof(fp_digit)); + fp_clamp(B); +} + #endif + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + diff --git a/fp_sqr_comba_generic.c b/fp_sqr_comba_generic.c index 446d794..3af3845 100644 --- a/fp_sqr_comba_generic.c +++ b/fp_sqr_comba_generic.c @@ -1,3 +1,13 @@ +/* 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@gmail.com + */ + /* generic comba squarer */ void fp_sqr_comba(fp_int *A, fp_int *B) { @@ -73,3 +83,7 @@ void fp_sqr_comba(fp_int *A, fp_int *B) fp_copy(dst, B); } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_sqrmod.c b/fp_sqrmod.c index a32c171..84c3feb 100644 --- a/fp_sqrmod.c +++ b/fp_sqrmod.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -17,3 +17,7 @@ int fp_sqrmod(fp_int *a, fp_int *b, fp_int *c) fp_sqr(a, &tmp); return fp_mod(&tmp, b, c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_sub.c b/fp_sub.c index c6a99d0..3ebadcb 100644 --- a/fp_sub.c +++ b/fp_sub.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -44,3 +44,7 @@ void fp_sub(fp_int *a, fp_int *b, fp_int *c) } } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_sub_d.c b/fp_sub_d.c index 890bb2b..8c00501 100644 --- a/fp_sub_d.c +++ b/fp_sub_d.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -16,3 +16,7 @@ void fp_sub_d(fp_int *a, fp_digit b, fp_int *c) fp_set(&tmp, b); fp_sub(a, &tmp, c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_submod.c b/fp_submod.c index ecfa4b7..edb3ddb 100644 --- a/fp_submod.c +++ b/fp_submod.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -18,3 +18,7 @@ int fp_submod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) return fp_mod(&tmp, c, d); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_to_signed_bin.c b/fp_to_signed_bin.c index 2a48483..525e1a6 100644 --- a/fp_to_signed_bin.c +++ b/fp_to_signed_bin.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -14,3 +14,7 @@ void fp_to_signed_bin(fp_int *a, unsigned char *b) fp_to_unsigned_bin (a, b + 1); b[0] = (unsigned char) ((a->sign == FP_ZPOS) ? 0 : 1); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_to_unsigned_bin.c b/fp_to_unsigned_bin.c index 40c15f9..700e564 100644 --- a/fp_to_unsigned_bin.c +++ b/fp_to_unsigned_bin.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -23,3 +23,7 @@ void fp_to_unsigned_bin(fp_int *a, unsigned char *b) } bn_reverse (b, x); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_toradix.c b/fp_toradix.c index 1a7c516..64113e0 100644 --- a/fp_toradix.c +++ b/fp_toradix.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -53,3 +53,7 @@ int fp_toradix(fp_int *a, char *str, int radix) *str = '\0'; return FP_OKAY; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/fp_unsigned_bin_size.c b/fp_unsigned_bin_size.c index 6ec52ee..c55c173 100644 --- a/fp_unsigned_bin_size.c +++ b/fp_unsigned_bin_size.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -14,3 +14,7 @@ int fp_unsigned_bin_size(fp_int *a) int size = fp_count_bits (a); return (size / 8 + ((size & 7) != 0 ? 1 : 0)); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/makefile b/makefile index 5bfc936..74a712c 100644 --- a/makefile +++ b/makefile @@ -10,7 +10,7 @@ CFLAGS += -Wall -W -Wshadow -I./ -O3 -funroll-all-loops #speed CFLAGS += -fomit-frame-pointer -VERSION=0.03 +VERSION=0.04 default: libtfm.a @@ -42,9 +42,37 @@ fp_read_radix.o fp_toradix.o fp_radix_size.o fp_count_bits.o fp_reverse.o fp_s_r \ fp_ident.o -libtfm.a: $(OBJECTS) - $(AR) $(ARFLAGS) libtfm.a $(OBJECTS) - ranlib libtfm.a +HEADERS=tfm.h + +ifndef LIBPATH + LIBPATH=/usr/lib +endif + +ifndef INCPATH + INCPATH=/usr/include +endif + +ifndef TFM_GROUP + GROUP=wheel +endif + +ifndef TFM_USER + USER=root +endif + +ifndef LIBNAME + LIBNAME=libtfm.a +endif + +$(LIBNAME): $(OBJECTS) + $(AR) $(ARFLAGS) $(LIBNAME) $(OBJECTS) + ranlib $(LIBNAME) + +install: libtfm.a + install -d -g $(GROUP) -o $(USER) $(DESTDIR)$(LIBPATH) + install -d -g $(GROUP) -o $(USER) $(DESTDIR)$(INCPATH) + install -g $(GROUP) -o $(USER) $(LIBNAME) $(DESTDIR)$(LIBPATH) + install -g $(GROUP) -o $(USER) $(HEADERS) $(DESTDIR)$(INCPATH) mtest/mtest: mtest/mtest.c cd mtest ; make mtest @@ -52,8 +80,14 @@ mtest/mtest: mtest/mtest.c test: libtfm.a demo/test.o mtest/mtest $(CC) $(CFLAGS) demo/test.o libtfm.a $(PROF) -o test +timing: libtfm.a demo/test.o + $(CC) $(CFLAGS) demo/test.o libtfm.a $(PROF) -o test + stest: libtfm.a demo/stest.o - $(CC) demo/stest.o libtfm.a -o stest + $(CC) $(CFLAGS) demo/stest.o libtfm.a -o stest + +rsatest: libtfm.a demo/rsa.o + $(CC) $(CFLAGS) demo/rsa.o libtfm.a -o rsatest docdvi: tfm.tex touch tfm.ind @@ -68,10 +102,15 @@ docs: docdvi mv -f tfm.pdf doc clean: - rm -f $(OBJECTS) *.a demo/*.o test tfm.aux tfm.dvi tfm.idx tfm.ilg tfm.ind tfm.lof tfm.log tfm.toc stest *~ + rm -f $(OBJECTS) *.a demo/*.o test tfm.aux tfm.dvi tfm.idx tfm.ilg tfm.ind tfm.lof tfm.log tfm.toc stest *~ rsatest *.gcda *.gcno demo/*.gcda demo/*.gcno mtest/*.gcno mtest/*.gcda cd mtest ; make clean -zipup: docs clean +no_oops: clean + cd .. ; cvs commit + echo Scanning for scratch/dirty files + find . -type f | grep -v CVS | xargs -n 1 bash mess.sh + +zipup: no_oops docs clean perl gen.pl ; mv mpi.c pre_gen/ ; \ cd .. ; rm -rf tfm* tomsfastmath-$(VERSION) ; mkdir tomsfastmath-$(VERSION) ; \ cp -R ./tomsfastmath/* ./tomsfastmath-$(VERSION)/ ; \ diff --git a/mess.sh b/mess.sh new file mode 100644 index 0000000..bf639ce --- /dev/null +++ b/mess.sh @@ -0,0 +1,4 @@ +#!/bin/bash +if cvs log $1 >/dev/null 2>/dev/null; then exit 0; else echo "$1 shouldn't be here" ; exit 1; fi + + diff --git a/mtest/makefile b/mtest/makefile index 8e42029..de6bf58 100644 --- a/mtest/makefile +++ b/mtest/makefile @@ -3,7 +3,7 @@ CFLAGS += -Wall -W -O3 default: mtest mtest: mtest.o - $(CC) mtest.o -ltommath -o mtest + $(CC) $(CFLAGS) mtest.o -ltommath -o mtest clean: rm -f *.o mtest *~ diff --git a/mtest/mtest.c b/mtest/mtest.c index 3747406..02fd483 100644 --- a/mtest/mtest.c +++ b/mtest/mtest.c @@ -60,7 +60,7 @@ void rand_num2(mp_int *a) int n, size; unsigned char buf[2048]; - size = 1 + ((fgetc(rng)<<8) + fgetc(rng)) % 32; + size = 1 + ((fgetc(rng)<<8) + fgetc(rng)) % 256; buf[0] = (fgetc(rng)&1)?1:0; fread(buf+1, 1, size, rng); while (buf[1] == 0) buf[1] = fgetc(rng); @@ -317,3 +317,7 @@ int main(void) fclose(rng); return 0; } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/pre_gen/mpi.c b/pre_gen/mpi.c index 68b3acb..08eaaa0 100644 --- a/pre_gen/mpi.c +++ b/pre_gen/mpi.c @@ -6,7 +6,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -35,6 +35,10 @@ void fp_2expt(fp_int *a, int b) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_2expt.c */ /* Start: fp_add.c */ @@ -45,7 +49,7 @@ void fp_2expt(fp_int *a, int b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -78,6 +82,10 @@ void fp_add(fp_int *a, fp_int *b, fp_int *c) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_add.c */ /* Start: fp_add_d.c */ @@ -88,7 +96,7 @@ void fp_add(fp_int *a, fp_int *b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -100,6 +108,10 @@ void fp_add_d(fp_int *a, fp_digit b, fp_int *c) fp_add(a,&tmp,c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_add_d.c */ /* Start: fp_addmod.c */ @@ -110,7 +122,7 @@ void fp_add_d(fp_int *a, fp_digit b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -123,6 +135,10 @@ int fp_addmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) return fp_mod(&tmp, c, d); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_addmod.c */ /* Start: fp_cmp.c */ @@ -133,7 +149,7 @@ int fp_addmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -154,6 +170,10 @@ int fp_cmp(fp_int *a, fp_int *b) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_cmp.c */ /* Start: fp_cmp_d.c */ @@ -164,7 +184,7 @@ int fp_cmp(fp_int *a, fp_int *b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -192,6 +212,10 @@ int fp_cmp_d(fp_int *a, fp_digit b) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_cmp_d.c */ /* Start: fp_cmp_mag.c */ @@ -202,7 +226,7 @@ int fp_cmp_d(fp_int *a, fp_digit b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -227,6 +251,10 @@ int fp_cmp_mag(fp_int *a, fp_int *b) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_cmp_mag.c */ /* Start: fp_cnt_lsb.c */ @@ -237,7 +265,7 @@ int fp_cmp_mag(fp_int *a, fp_int *b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -273,6 +301,10 @@ int fp_cnt_lsb(fp_int *a) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_cnt_lsb.c */ /* Start: fp_count_bits.c */ @@ -283,7 +315,7 @@ int fp_cnt_lsb(fp_int *a) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -309,6 +341,10 @@ int fp_count_bits (fp_int * a) return r; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_count_bits.c */ /* Start: fp_div.c */ @@ -319,7 +355,7 @@ int fp_count_bits (fp_int * a) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -466,6 +502,10 @@ int fp_div(fp_int *a, fp_int *b, fp_int *c, fp_int *d) return FP_OKAY; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_div.c */ /* Start: fp_div_2.c */ @@ -476,7 +516,7 @@ int fp_div(fp_int *a, fp_int *b, fp_int *c, fp_int *d) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -519,6 +559,10 @@ void fp_div_2(fp_int * a, fp_int * b) fp_clamp (b); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_div_2.c */ /* Start: fp_div_2d.c */ @@ -529,7 +573,7 @@ void fp_div_2(fp_int * a, fp_int * b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -598,6 +642,10 @@ void fp_div_2d(fp_int *a, int b, fp_int *c, fp_int *d) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_div_2d.c */ /* Start: fp_div_d.c */ @@ -608,7 +656,7 @@ void fp_div_2d(fp_int *a, int b, fp_int *c, fp_int *d) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -691,6 +739,10 @@ int fp_div_d(fp_int *a, fp_digit b, fp_int *c, fp_digit *d) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_div_d.c */ /* Start: fp_exptmod.c */ @@ -701,7 +753,7 @@ int fp_div_d(fp_int *a, fp_digit b, fp_int *c, fp_digit *d) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -870,6 +922,13 @@ int fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y) fp_int tmp; int err; +#ifdef TFM_CHECK + /* prevent overflows */ + if (P->used > (FP_SIZE/2)) { + return FP_VAL; + } +#endif + /* is X negative? */ if (X->sign == FP_NEG) { /* yes, copy G and invmod it */ @@ -879,7 +938,9 @@ int fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y) } X->sign = FP_ZPOS; err = _fp_exptmod(&tmp, X, P, Y); - X->sign = FP_NEG; + if (X != Y) { + X->sign = FP_NEG; + } return err; } else { /* Positive exponent so just exptmod */ @@ -887,6 +948,10 @@ int fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_exptmod.c */ /* Start: fp_gcd.c */ @@ -897,7 +962,7 @@ int fp_exptmod(fp_int * G, fp_int * X, fp_int * P, fp_int * Y) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -942,9 +1007,22 @@ void fp_gcd(fp_int *a, fp_int *b, fp_int *c) fp_copy(&u, c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_gcd.c */ /* Start: fp_ident.c */ +/* 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@gmail.com + */ #include "tfm.h" const char *fp_ident(void) @@ -986,9 +1064,6 @@ const char *fp_ident(void) #ifdef FP_64BIT " FP_64BIT " #endif -#ifdef TFM_LARGE -" TFM_LARGE " -#endif #ifdef TFM_HUGE " TFM_HUGE " #endif @@ -1012,6 +1087,10 @@ int main(void) #endif +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_ident.c */ /* Start: fp_invmod.c */ @@ -1022,7 +1101,7 @@ int main(void) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1114,6 +1193,10 @@ top: return FP_OKAY; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_invmod.c */ /* Start: fp_isprime.c */ @@ -1124,7 +1207,7 @@ top: * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1192,6 +1275,10 @@ int fp_isprime(fp_int *a) return FP_YES; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_isprime.c */ /* Start: fp_lcm.c */ @@ -1202,7 +1289,7 @@ int fp_isprime(fp_int *a) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1223,6 +1310,10 @@ void fp_lcm(fp_int *a, fp_int *b, fp_int *c) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_lcm.c */ /* Start: fp_lshd.c */ @@ -1233,7 +1324,7 @@ void fp_lcm(fp_int *a, fp_int *b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1261,6 +1352,10 @@ void fp_lshd(fp_int *a, int x) fp_clamp(a); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_lshd.c */ /* Start: fp_mod.c */ @@ -1271,7 +1366,7 @@ void fp_lshd(fp_int *a, int x) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1295,6 +1390,10 @@ int fp_mod(fp_int *a, fp_int *b, fp_int *c) +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mod.c */ /* Start: fp_mod_2d.c */ @@ -1305,7 +1404,7 @@ int fp_mod(fp_int *a, fp_int *b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1337,6 +1436,10 @@ void fp_mod_2d(fp_int *a, int b, fp_int *c) fp_clamp (c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mod_2d.c */ /* Start: fp_mod_d.c */ @@ -1347,7 +1450,7 @@ void fp_mod_2d(fp_int *a, int b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1357,6 +1460,10 @@ int fp_mod_d(fp_int *a, fp_digit b, fp_digit *c) return fp_div_d(a, b, NULL, c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mod_d.c */ /* Start: fp_montgomery_calc_normalization.c */ @@ -1367,7 +1474,7 @@ int fp_mod_d(fp_int *a, fp_digit b, fp_digit *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1399,261 +1506,393 @@ void fp_montgomery_calc_normalization(fp_int *a, fp_int *b) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_montgomery_calc_normalization.c */ /* Start: fp_montgomery_reduce.c */ -/* 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 - -#if defined(TFM_X86) - -/* x86-32 code */ - -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -#define INNERMUL \ -asm( \ -"movl %7,%%eax \n\t" \ -"mull %6 \n\t" \ -"addl %%eax,%0 \n\t" \ -"adcl %%edx,%1 \n\t" \ -"adcl $0,%2 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(mu), "g"(*tmpm++) \ - : "%eax", "%edx", "%cc"); - -#define PROPCARRY \ -asm( \ -"movl %1,%%eax \n\t" \ -"addl %%eax,%6 \n\t" \ -"movl %2,%%eax \n\t" \ -"adcl %%eax,%7 \n\t" \ -"adcl $0,%8 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "m"(_c[OFF0+1]), "m"(_c[OFF1+1]), "m"(_c[OFF2+1]) \ -: "%eax", "%cc"); - -#elif defined(TFM_X86_64) -/* x86-64 code */ - -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -#define INNERMUL \ -asm( \ -"movq %7,%%rax \n\t" \ -"mulq %6 \n\t" \ -"addq %%rax,%0 \n\t" \ -"adcq %%rdx,%1 \n\t" \ -"adcq $0,%2 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(mu), "g"(*tmpm++) \ - : "%rax", "%rdx", "%cc"); - -#define PROPCARRY \ -asm( \ -"movq %1,%%rax \n\t" \ -"movq %2,%%rbx \n\t" \ -"addq %%rax,%6 \n\t" \ -"adcq %%rbx,%7 \n\t" \ -"adcq $0,%8 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "m"(_c[OFF0+1]), "m"(_c[OFF1+1]), "m"(_c[OFF2+1]) \ -: "%rax", "%rbx", "%cc"); - -#elif defined(TFM_SSE2) - -/* SSE2 code */ - -#define MONT_START \ -asm("movd %0,%%mm2"::"g"(mp)); - -#define MONT_FINI \ -asm("emms"); - -#define LOOP_START \ -asm(\ -"movd %0,%%mm1 \n\t" \ -"pmuludq %%mm2,%%mm1 \n\t" \ -:: "g"(c[x])); - -#define INNERMUL \ -asm( \ -"movd %6,%%mm0 \n\t" \ -"pmuludq %%mm1,%%mm0 \n\t" \ -"movd %%mm0,%%eax \n\t" \ -"psrlq $32, %%mm0 \n\t" \ -"addl %%eax,%0 \n\t" \ -"movd %%mm0,%%eax \n\t" \ -"adcl %%eax,%1 \n\t" \ -"adcl $0,%2 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(*tmpm++) \ - : "%eax", "%cc"); - -#define PROPCARRY \ -asm( \ -"movl %1,%%eax \n\t" \ -"addl %%eax,%6 \n\t" \ -"movl %2,%%eax \n\t" \ -"adcl %%eax,%7 \n\t" \ -"adcl $0,%8 \n\t" \ -:"=g"(_c[OFF0]), "=g"(_c[OFF1]), "=g"(_c[OFF2]):"0"(_c[OFF0]), "1"(_c[OFF1]), "2"(_c[OFF2]), \ - "g"(_c[OFF0+1]), "g"(_c[OFF1+1]), "g"(_c[OFF2+1]) \ -: "%eax", "%cc"); - -#elif defined(TFM_ARM) - -/* ISO C code */ -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -/* NOTE: later write it using two regs instead of three for _c + ... */ -#define INNERMUL \ -asm( \ -"UMULL r0,r1,%0,%1 \n\t" \ -"LDR r2,[%2] \n\t" \ -"ADDS r2,r2,r0 \n\t" \ -"STR r2,[%2] \n\t" \ -"LDR r2,[%3] \n\t" \ -"ADCS r2,r2,r1 \n\t" \ -"STR r2,[%3] \n\t" \ -"LDR r2,[%4] \n\t" \ -"ADC r2,r2,#0 \n\t" \ -"STR r2,[%4] \n\t" \ -::"r"(mu),"r"(*tmpm++),"r"(_c + OFF0),"r"(_c + OFF1),"r"(_c + OFF2):"r0", "r1", "r2", "%cc"); - -#define PROPCARRY \ -asm( \ -"LDR r0,[%1] \n\t" \ -"LDR r1,[%0,#4] \n\t" \ -"ADDS r0,r0,r1 \n\t" \ -"STR r0,[%0,#4] \n\t" \ -"LDR r0,[%2] \n\t" \ -"LDR r1,[%1,#4] \n\t" \ -"ADCS r0,r0,r1 \n\t" \ -"STR r0,[%1,#4] \n\t" \ -"LDR r0,[%2,#4] \n\t" \ -"ADC r0,r0,#0 \n\t" \ -"STR r0,[%2,#4] \n\t" \ -::"r"(_c + OFF0),"r"(_c + OFF1),"r"(_c + OFF2):"r0", "r1", "%cc"); - -#else - -/* ISO C code */ -#define MONT_START - -#define MONT_FINI - -#define LOOP_START \ - mu = c[x] * mp; - -#define INNERMUL \ - do { fp_word t; \ - t = (fp_word)_c[OFF0] + ((fp_word)mu) * ((fp_word)*tmpm++); _c[OFF0] = t; \ - t = (fp_word)_c[OFF1] + (t >> DIGIT_BIT); _c[OFF1] = t; \ - _c[OFF2] += (t >> DIGIT_BIT); \ - } while (0); - -#define PROPCARRY \ - do { fp_word t; \ - t = (fp_word)_c[OFF0+1] + (fp_word)_c[OFF1]; _c[OFF0+1] = t; \ - t = (fp_word)_c[OFF1+1] + (t >> DIGIT_BIT) + (fp_word)_c[OFF2]; _c[OFF1+1] = t; \ - _c[OFF2+1] += (t >> DIGIT_BIT); \ - } while (0); - -#endif - - -#define OFF0 (0) -#define OFF1 (FP_SIZE) -#define OFF2 (FP_SIZE+FP_SIZE) - -/* computes x/R == x (mod N) via Montgomery Reduction */ -void fp_montgomery_reduce(fp_int *a, fp_int *m, fp_digit mp) -{ - fp_digit c[3*FP_SIZE], *_c, *tmpm, mu; - int oldused, x, y, pa; - - /* now zero the buff */ - pa = m->used; - memset(c, 0, sizeof(c)); - - /* copy the input */ - oldused = a->used; - for (x = 0; x < oldused; x++) { - c[x] = a->dp[x]; - } - - MONT_START; - - /* now let's get bizz-sy! */ - for (x = 0; x < pa; x++) { - /* get Mu for this round */ - LOOP_START; - - /* our friendly neighbourhood alias */ - _c = c + x; - tmpm = m->dp; - - for (y = 0; y < pa; y++) { - INNERMUL; - ++_c; - } - /* send carry up man... */ - _c = c + x; - PROPCARRY; - } - - /* fix the rest of the carries */ - _c = c + pa; - for (x = pa; x < pa * 2 + 2; x++) { - PROPCARRY; - ++_c; - } - - /* now copy out */ - _c = c + pa; - tmpm = a->dp; - for (x = 0; x < pa+1; x++) { - *tmpm++ = *_c++; - } - - for (; x < oldused; x++) { - *tmpm++ = 0; - } - - MONT_FINI; - - a->used = pa+1; - fp_clamp(a); - - /* if A >= m then A = A - m */ - if (fp_cmp_mag (a, m) != FP_LT) { - s_fp_sub (a, m, a); - } -} +/* 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@gmail.com + */ +#include + +/******************************************************************/ +#if defined(TFM_X86) +/* x86-32 code */ + +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + "movl %5,%%eax \n\t" \ + "mull %4 \n\t" \ + "addl %1,%%eax \n\t" \ + "adcl $0,%%edx \n\t" \ + "addl %%eax,%0 \n\t" \ + "adcl $0,%%edx \n\t" \ + "movl %%edx,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy), "g"(mu), "g"(*tmpm++) \ +: "%eax", "%edx", "%cc") + +#define PROPCARRY \ +asm( \ + "addl %1,%0 \n\t" \ + "setb %%al \n\t" \ + "movzbl %%al,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy) \ +: "%eax", "%cc") + +/******************************************************************/ +#elif defined(TFM_X86_64) +/* x86-64 code */ + +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + "movq %5,%%rax \n\t" \ + "mulq %4 \n\t" \ + "addq %1,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "addq %%rax,%0 \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rdx,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy), "r"(mu), "r"(*tmpm++) \ +: "%rax", "%rdx", "%cc") + +#define INNERMUL8 \ + asm( \ + "movq 0(%5),%%rax \n\t" \ + "movq 0(%2),%%r10 \n\t" \ + "movq 0x8(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x8(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x10(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x10(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x8(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x18(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x18(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x10(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x20(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x20(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x18(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x28(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x28(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x20(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x30(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x30(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x28(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "movq 0x38(%5),%%r11 \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq 0x38(%2),%%r10 \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x30(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ + "movq %%r11,%%rax \n\t" \ + "mulq %4 \n\t" \ + "addq %%r10,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "addq %3,%%rax \n\t" \ + "adcq $0,%%rdx \n\t" \ + "movq %%rax,0x38(%0) \n\t" \ + "movq %%rdx,%1 \n\t" \ + \ +:"=r"(_c), "=r"(cy) \ +: "0"(_c), "1"(cy), "g"(mu), "r"(tmpm)\ +: "%rax", "%rdx", "%r10", "%r11", "%cc") + + +#define PROPCARRY \ +asm( \ + "addq %1,%0 \n\t" \ + "setb %%al \n\t" \ + "movzbq %%al,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy) \ +: "%rax", "%cc") + +/******************************************************************/ +#elif defined(TFM_SSE2) +/* SSE2 code (assumes 32-bit fp_digits) */ +/* XMM register assignments: + * xmm0 *tmpm++, then Mu * (*tmpm++) + * xmm1 c[x], then Mu + * xmm2 mp + * xmm3 cy + * xmm4 _c[LO] + */ + +#define MONT_START \ + asm("movd %0,%%mm2"::"g"(mp)) + +#define MONT_FINI \ + asm("emms") + +#define LOOP_START \ +asm( \ +"movd %0,%%mm1 \n\t" \ +"pxor %%mm3,%%mm3 \n\t" \ +"pmuludq %%mm2,%%mm1 \n\t" \ +:: "g"(c[x])) + +/* pmuludq on mmx registers does a 32x32->64 multiply. */ +#define INNERMUL \ +asm( \ + "movd %1,%%mm4 \n\t" \ + "movd %2,%%mm0 \n\t" \ + "paddq %%mm4,%%mm3 \n\t" \ + "pmuludq %%mm1,%%mm0 \n\t" \ + "paddq %%mm0,%%mm3 \n\t" \ + "movd %%mm3,%0 \n\t" \ + "psrlq $32, %%mm3 \n\t" \ +:"=g"(_c[LO]) : "0"(_c[LO]), "g"(*tmpm++) ); + +#define LOOP_END \ +asm( "movd %%mm3,%0 \n" :"=r"(cy)) + +#define PROPCARRY \ +asm( \ + "addl %1,%0 \n\t" \ + "setb %%al \n\t" \ + "movzbl %%al,%1 \n\t" \ +:"=g"(_c[LO]), "=r"(cy) \ +:"0"(_c[LO]), "1"(cy) \ +: "%eax", "%cc") + +/******************************************************************/ +#elif defined(TFM_ARM) + /* ARMv4 code */ + +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + " LDR r0,%1 \n\t" \ + " ADDS r0,r0,%0 \n\t" \ + " MOVCS %0,#1 \n\t" \ + " MOVCC %0,#0 \n\t" \ + " UMLAL r0,%0,%3,%4 \n\t" \ + " STR r0,%1 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"r"(mu),"r"(*tmpm++),"1"(_c[0]):"r0","%cc"); + +#define PROPCARRY \ +asm( \ + " LDR r0,%1 \n\t" \ + " ADDS r0,r0,%0 \n\t" \ + " STR r0,%1 \n\t" \ + " MOVCS %0,#1 \n\t" \ + " MOVCC %0,#0 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"1"(_c[0]):"r0","%cc"); + +#elif defined(TFM_PPC32) + +/* PPC32 */ +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ +asm( \ + " mullw r16,%3,%4 \n\t" \ + " mulhwu r17,%3,%4 \n\t" \ + " addc r16,r16,%0 \n\t" \ + " addze r17,r17 \n\t" \ + " lwz r18,%1 \n\t" \ + " addc r16,r16,r18 \n\t" \ + " addze %0,r17 \n\t" \ + " stw r16,%1 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"r"(mu),"r"(*tmpm++),"1"(_c[0]):"r16", "r17", "r18","%cc"); + +#define PROPCARRY \ +asm( \ + " lwz r16,%1 \n\t" \ + " addc r16,r16,%0 \n\t" \ + " stw r16,%1 \n\t" \ + " xor %0,%0,%0 \n\t" \ + " addze %0,%0 \n\t" \ +:"=r"(cy),"=m"(_c[0]):"0"(cy),"1"(_c[0]):"r16","%cc"); + +/******************************************************************/ +#else + +/* ISO C code */ +#define MONT_START +#define MONT_FINI +#define LOOP_END +#define LOOP_START \ + mu = c[x] * mp + +#define INNERMUL \ + do { fp_word t; \ + _c[0] = t = ((fp_word)_c[0] + (fp_word)cy) + \ + (((fp_word)mu) * ((fp_word)*tmpm++)); \ + cy = (t >> DIGIT_BIT); \ + } while (0) + +#define PROPCARRY \ + do { fp_digit t = _c[0] += cy; cy = (t < cy); } while (0) + +#endif +/******************************************************************/ + + +#define LO 0 +#define HI 1 +#define CY 2 + +/* computes x/R == x (mod N) via Montgomery Reduction */ +void fp_montgomery_reduce(fp_int *a, fp_int *m, fp_digit mp) +{ + fp_digit c[FP_SIZE], *_c, *tmpm, mu; + int oldused, x, y, pa; + +#if defined(USE_MEMSET) + /* now zero the buff */ + memset(c, 0, sizeof c); +#endif + pa = m->used; + + /* copy the input */ + oldused = a->used; + for (x = 0; x < oldused; x++) { + c[x] = a->dp[x]; + } +#if !defined(USE_MEMSET) + for (; x < 2*pa+3; x++) { + c[x] = 0; + } +#endif + MONT_START; + + for (x = 0; x < pa; x++) { + fp_digit cy = 0; + /* get Mu for this round */ + LOOP_START; + _c = c + x; + tmpm = m->dp; + y = 0; + #if defined(TFM_X86_64) + for (; y < (pa & ~7); y += 8) { + INNERMUL8; + _c += 8; + tmpm += 8; + } + #endif + + for (; y < pa; y++) { + INNERMUL; + ++_c; + } + LOOP_END; + while (cy) { + PROPCARRY; // cy = cy > (*_c += cy); + ++_c; + } + } + + /* now copy out */ + _c = c + pa; + tmpm = a->dp; + for (x = 0; x < pa+1; x++) { + *tmpm++ = *_c++; + } + + for (; x < oldused; x++) { + *tmpm++ = 0; + } + + MONT_FINI; + + a->used = pa+1; + fp_clamp(a); + + /* if A >= m then A = A - m */ + if (fp_cmp_mag (a, m) != FP_LT) { + s_fp_sub (a, m, a); + } +} + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_montgomery_reduce.c */ @@ -1665,7 +1904,7 @@ void fp_montgomery_reduce(fp_int *a, fp_int *m, fp_digit mp) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1703,6 +1942,10 @@ int fp_montgomery_setup(fp_int *a, fp_digit *rho) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_montgomery_setup.c */ /* Start: fp_mul.c */ @@ -1713,7 +1956,7 @@ int fp_montgomery_setup(fp_int *a, fp_digit *rho) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1732,19 +1975,26 @@ void fp_mul(fp_int *A, fp_int *B, fp_int *C) inputs are not close to the next power of two. That is, for example, if say y=17 then we would do (32-17)^2 = 225 unneeded multiplications */ - if (y <= 4) { - fp_mul_comba4(A,B,C); - } else if (y <= 8) { - fp_mul_comba8(A,B,C); -#if defined(TFM_LARGE) - } else if (y <= 16 && y >= 10) { - fp_mul_comba16(A,B,C); + +#ifdef TFM_SMALL_SET + if (y <= 16) { + fp_mul_comba_small(A,B,C); +#elif defined(TFM_HUGE) + if (0) { 1; #endif #if defined(TFM_HUGE) - } else if (y <= 32 && y >= 24) { + } else if (y <= 32) { fp_mul_comba32(A,B,C); + } else if (y <= 48) { + fp_mul_comba48(A,B,C); + } else if (y <= 64) { + fp_mul_comba64(A,B,C); #endif +#if !defined(TFM_HUGE) && !defined(TFM_SMALL_SET) + { +#else } else { +#endif fp_mul_comba(A,B,C); } } else { @@ -1752,7 +2002,7 @@ void fp_mul(fp_int *A, fp_int *B, fp_int *C) if A = ab and B = cd for ||a|| = r we need to solve - ac*r^2 + (-(a-b)(c-d) + ac + bd)*r + bd + ac*r^2 + ((a+b)(c+d) - (ac + bd))*r + bd So we solve for the three products then we form the final result with careful shifting and addition. @@ -1780,7 +2030,7 @@ Obvious points of optimization } else { t1.used = 0; } - t1.sign = A->sign; + t1.sign = 0; // fp_copy(B, &t2); fp_rshd(&t2, r); for (s = 0; s < B->used - r; s++) { @@ -1794,7 +2044,7 @@ Obvious points of optimization } else { t2.used = 0; } - t2.sign = B->sign; + t2.sign = 0; fp_copy(&t1, &amb); fp_copy(&t2, &cmd); fp_zero(&ac); @@ -1808,7 +2058,7 @@ Obvious points of optimization t2.dp[s] = B->dp[s]; } for (; s < FP_SIZE; s++) { - t1.dp[s] = 0; + t1.dp[s] = 0; t2.dp[s] = 0; } t1.used = r; @@ -1816,18 +2066,17 @@ Obvious points of optimization fp_clamp(&t1); fp_clamp(&t2); - fp_sub(&amb, &t1, &amb); fp_sub(&cmd, &t2, &cmd); + s_fp_add(&amb, &t1, &amb); s_fp_add(&cmd, &t2, &cmd); fp_zero(&bd); fp_mul(&t1, &t2, &bd); - /* now get the (a-b)(c-d) term */ + /* now get the (a+b)(c+d) term */ fp_zero(&comp); fp_mul(&amb, &cmd, &comp); /* now solve the system, do the middle term first */ - comp.sign ^= 1; - fp_add(&comp, &ac, &comp); - fp_add(&comp, &bd, &comp); + s_fp_sub(&comp, &ac, &comp); + s_fp_sub(&comp, &bd, &comp); fp_lshd(&comp, r); /* leading term */ @@ -1843,6 +2092,10 @@ Obvious points of optimization } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mul.c */ /* Start: fp_mul_2.c */ @@ -1853,7 +2106,7 @@ Obvious points of optimization * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1910,6 +2163,10 @@ void fp_mul_2(fp_int * a, fp_int * b) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mul_2.c */ /* Start: fp_mul_2d.c */ @@ -1920,7 +2177,7 @@ void fp_mul_2(fp_int * a, fp_int * b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -1957,6 +2214,10 @@ void fp_mul_2d(fp_int *a, int b, fp_int *c) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mul_2d.c */ /* Start: fp_mul_comba.c */ @@ -1967,7 +2228,7 @@ void fp_mul_2d(fp_int *a, int b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ /* About this file... @@ -1976,6 +2237,11 @@ void fp_mul_2d(fp_int *a, int b, fp_int *c) #include +#if defined(TFM_PRESCOTT) && defined(TFM_SSE2) + #undef TFM_SSE2 + #define TFM_X86 +#endif + /* these are the combas. Worship them. */ #if defined(TFM_X86) /* Generic x86 optimized code */ @@ -2111,9 +2377,38 @@ asm( \ " UMULL r0,r1,%6,%7 \n\t" \ " ADDS %0,%0,r0 \n\t" \ " ADCS %1,%1,r1 \n\t" \ -" ADC %2, %2, #0 \n\t" \ +" ADC %2,%2,#0 \n\t" \ :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j) : "r0", "r1", "%cc"); +#elif defined(TFM_PPC32) +/* For 32-bit PPC */ + +#define COMBA_START + +#define COMBA_CLEAR \ + c0 = c1 = c2 = 0; + +#define COMBA_FORWARD \ + do { c0 = c1; c1 = c2; c2 = 0; } while (0); + +#define COMBA_STORE(x) \ + x = c0; + +#define COMBA_STORE2(x) \ + x = c1; + +#define COMBA_FINI + +/* untested: will mulhwu change the flags? Docs say no */ +#define MULADD(i, j) \ +asm( \ + " mullw r16,%6,%7 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " mulhwu r16,%6,%7 \n\t" \ + " adde %1,%1,r16 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r16"); + #else /* ISO C code */ @@ -2199,267 +2494,1231 @@ void fp_mul_comba(fp_int *A, fp_int *B, fp_int *C) fp_copy(dst, C); } -void fp_mul_comba4(fp_int *A, fp_int *B, fp_int *C) -{ - fp_digit c0, c1, c2, at[8]; - - memcpy(at, A->dp, 4 * sizeof(fp_digit)); - memcpy(at+4, B->dp, 4 * sizeof(fp_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; - fp_clamp(C); - COMBA_FINI; -} - - -void fp_mul_comba8(fp_int *A, fp_int *B, fp_int *C) -{ - fp_digit c0, c1, c2, at[16]; - - memcpy(at, A->dp, 8 * sizeof(fp_digit)); - memcpy(at+8, B->dp, 8 * sizeof(fp_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; - fp_clamp(C); - COMBA_FINI; -} - -#if defined(TFM_LARGE) - -void fp_mul_comba16(fp_int *A, fp_int *B, fp_int *C) +#if defined(TFM_SMALL_SET) +void fp_mul_comba_small(fp_int *A, fp_int *B, fp_int *C) { fp_digit c0, c1, c2, at[32]; + switch (MAX(A->used, B->used)) { - memcpy(at, A->dp, 16 * sizeof(fp_digit)); - memcpy(at+16, B->dp, 16 * sizeof(fp_digit)); - COMBA_START; + case 1: + memcpy(at, A->dp, 1 * sizeof(fp_digit)); + memcpy(at+1, B->dp, 1 * sizeof(fp_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; - fp_clamp(C); - COMBA_FINI; + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[1]); + COMBA_STORE(C->dp[0]); + COMBA_STORE2(C->dp[1]); + C->used = 2; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 2: + memcpy(at, A->dp, 2 * sizeof(fp_digit)); + memcpy(at+2, B->dp, 2 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[2]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[3]); MULADD(at[1], at[2]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[1], at[3]); + COMBA_STORE(C->dp[2]); + COMBA_STORE2(C->dp[3]); + C->used = 4; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 3: + memcpy(at, A->dp, 3 * sizeof(fp_digit)); + memcpy(at+3, B->dp, 3 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[3]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[4]); MULADD(at[1], at[3]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[5]); MULADD(at[1], at[4]); MULADD(at[2], at[3]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[1], at[5]); MULADD(at[2], at[4]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[2], at[5]); + COMBA_STORE(C->dp[4]); + COMBA_STORE2(C->dp[5]); + C->used = 6; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 4: + memcpy(at, A->dp, 4 * sizeof(fp_digit)); + memcpy(at+4, B->dp, 4 * sizeof(fp_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; + fp_clamp(C); + COMBA_FINI; + break; + + case 5: + memcpy(at, A->dp, 5 * sizeof(fp_digit)); + memcpy(at+5, B->dp, 5 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[5]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[6]); MULADD(at[1], at[5]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[7]); MULADD(at[1], at[6]); MULADD(at[2], at[5]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[8]); MULADD(at[1], at[7]); MULADD(at[2], at[6]); MULADD(at[3], at[5]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[9]); MULADD(at[1], at[8]); MULADD(at[2], at[7]); MULADD(at[3], at[6]); MULADD(at[4], at[5]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[1], at[9]); MULADD(at[2], at[8]); MULADD(at[3], at[7]); MULADD(at[4], at[6]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[2], at[9]); MULADD(at[3], at[8]); MULADD(at[4], at[7]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[3], at[9]); MULADD(at[4], at[8]); + COMBA_STORE(C->dp[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[4], at[9]); + COMBA_STORE(C->dp[8]); + COMBA_STORE2(C->dp[9]); + C->used = 10; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 6: + memcpy(at, A->dp, 6 * sizeof(fp_digit)); + memcpy(at+6, B->dp, 6 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[6]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[7]); MULADD(at[1], at[6]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[8]); MULADD(at[1], at[7]); MULADD(at[2], at[6]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[9]); MULADD(at[1], at[8]); MULADD(at[2], at[7]); MULADD(at[3], at[6]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[10]); MULADD(at[1], at[9]); MULADD(at[2], at[8]); MULADD(at[3], at[7]); MULADD(at[4], at[6]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); MULADD(at[3], at[8]); MULADD(at[4], at[7]); MULADD(at[5], at[6]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[1], at[11]); MULADD(at[2], at[10]); MULADD(at[3], at[9]); MULADD(at[4], at[8]); MULADD(at[5], at[7]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[2], at[11]); MULADD(at[3], at[10]); MULADD(at[4], at[9]); MULADD(at[5], at[8]); + COMBA_STORE(C->dp[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[3], at[11]); MULADD(at[4], at[10]); MULADD(at[5], at[9]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[4], at[11]); MULADD(at[5], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[5], at[11]); + COMBA_STORE(C->dp[10]); + COMBA_STORE2(C->dp[11]); + C->used = 12; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 7: + memcpy(at, A->dp, 7 * sizeof(fp_digit)); + memcpy(at+7, B->dp, 7 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[7]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[8]); MULADD(at[1], at[7]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[9]); MULADD(at[1], at[8]); MULADD(at[2], at[7]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[10]); MULADD(at[1], at[9]); MULADD(at[2], at[8]); MULADD(at[3], at[7]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); MULADD(at[3], at[8]); MULADD(at[4], at[7]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); MULADD(at[5], at[7]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); MULADD(at[6], at[7]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + 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[7]); + /* 8 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[3], at[13]); MULADD(at[4], at[12]); MULADD(at[5], at[11]); MULADD(at[6], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[4], at[13]); MULADD(at[5], at[12]); MULADD(at[6], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[5], at[13]); MULADD(at[6], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[6], at[13]); + COMBA_STORE(C->dp[12]); + COMBA_STORE2(C->dp[13]); + C->used = 14; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 8: + memcpy(at, A->dp, 8 * sizeof(fp_digit)); + memcpy(at+8, B->dp, 8 * sizeof(fp_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; + fp_clamp(C); + COMBA_FINI; + break; + + case 9: + memcpy(at, A->dp, 9 * sizeof(fp_digit)); + memcpy(at+9, B->dp, 9 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[9]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[10]); MULADD(at[1], at[9]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); MULADD(at[2], at[9]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[12]); MULADD(at[1], at[11]); MULADD(at[2], at[10]); MULADD(at[3], at[9]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); 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[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); 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]); MULADD(at[8], at[9]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[1], at[17]); MULADD(at[2], at[16]); 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]); MULADD(at[8], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); MULADD(at[8], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[3], at[17]); MULADD(at[4], at[16]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[4], at[17]); MULADD(at[5], at[16]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + MULADD(at[5], at[17]); MULADD(at[6], at[16]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + MULADD(at[6], at[17]); MULADD(at[7], at[16]); MULADD(at[8], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + MULADD(at[7], at[17]); MULADD(at[8], at[16]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[8], at[17]); + COMBA_STORE(C->dp[16]); + COMBA_STORE2(C->dp[17]); + C->used = 18; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 10: + memcpy(at, A->dp, 10 * sizeof(fp_digit)); + memcpy(at+10, B->dp, 10 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[10]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[11]); MULADD(at[1], at[10]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[12]); MULADD(at[1], at[11]); MULADD(at[2], at[10]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[13]); MULADD(at[1], at[12]); MULADD(at[2], at[11]); MULADD(at[3], at[10]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); 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[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); 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]); MULADD(at[8], at[10]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); MULADD(at[8], at[11]); MULADD(at[9], at[10]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[1], at[19]); MULADD(at[2], at[18]); MULADD(at[3], at[17]); MULADD(at[4], at[16]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); MULADD(at[9], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[2], at[19]); MULADD(at[3], at[18]); MULADD(at[4], at[17]); MULADD(at[5], at[16]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); MULADD(at[9], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[3], at[19]); MULADD(at[4], at[18]); MULADD(at[5], at[17]); MULADD(at[6], at[16]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + MULADD(at[4], at[19]); MULADD(at[5], at[18]); MULADD(at[6], at[17]); MULADD(at[7], at[16]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + MULADD(at[5], at[19]); MULADD(at[6], at[18]); MULADD(at[7], at[17]); MULADD(at[8], at[16]); MULADD(at[9], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + MULADD(at[6], at[19]); MULADD(at[7], at[18]); MULADD(at[8], at[17]); MULADD(at[9], at[16]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[7], at[19]); MULADD(at[8], at[18]); MULADD(at[9], at[17]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[8], at[19]); MULADD(at[9], at[18]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[9], at[19]); + COMBA_STORE(C->dp[18]); + COMBA_STORE2(C->dp[19]); + C->used = 20; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 11: + memcpy(at, A->dp, 11 * sizeof(fp_digit)); + memcpy(at+11, B->dp, 11 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[11]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[12]); MULADD(at[1], at[11]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[13]); MULADD(at[1], at[12]); MULADD(at[2], at[11]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[14]); MULADD(at[1], at[13]); MULADD(at[2], at[12]); MULADD(at[3], at[11]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); 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[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); MULADD(at[8], at[11]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); MULADD(at[9], at[11]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); MULADD(at[9], at[12]); MULADD(at[10], at[11]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); MULADD(at[10], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); MULADD(at[10], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[10], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[7], at[21]); MULADD(at[8], at[20]); MULADD(at[9], at[19]); MULADD(at[10], at[18]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[8], at[21]); MULADD(at[9], at[20]); MULADD(at[10], at[19]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[9], at[21]); MULADD(at[10], at[20]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[10], at[21]); + COMBA_STORE(C->dp[20]); + COMBA_STORE2(C->dp[21]); + C->used = 22; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 12: + memcpy(at, A->dp, 12 * sizeof(fp_digit)); + memcpy(at+12, B->dp, 12 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[12]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[13]); MULADD(at[1], at[12]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[14]); MULADD(at[1], at[13]); MULADD(at[2], at[12]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[15]); MULADD(at[1], at[14]); MULADD(at[2], at[13]); MULADD(at[3], at[12]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); MULADD(at[2], at[14]); MULADD(at[3], at[13]); MULADD(at[4], at[12]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); MULADD(at[3], at[14]); MULADD(at[4], at[13]); MULADD(at[5], at[12]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); MULADD(at[4], at[14]); MULADD(at[5], at[13]); MULADD(at[6], at[12]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); MULADD(at[7], at[12]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); MULADD(at[8], at[12]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); MULADD(at[9], at[12]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); MULADD(at[10], at[12]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); MULADD(at[10], at[13]); MULADD(at[11], at[12]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); MULADD(at[11], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + 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]); MULADD(at[10], at[15]); MULADD(at[11], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[11], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[8], at[23]); MULADD(at[9], at[22]); MULADD(at[10], at[21]); MULADD(at[11], at[20]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[9], at[23]); MULADD(at[10], at[22]); MULADD(at[11], at[21]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[10], at[23]); MULADD(at[11], at[22]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[11], at[23]); + COMBA_STORE(C->dp[22]); + COMBA_STORE2(C->dp[23]); + C->used = 24; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 13: + memcpy(at, A->dp, 13 * sizeof(fp_digit)); + memcpy(at+13, B->dp, 13 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[13]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[14]); MULADD(at[1], at[13]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[15]); MULADD(at[1], at[14]); MULADD(at[2], at[13]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); MULADD(at[2], at[14]); MULADD(at[3], at[13]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); MULADD(at[3], at[14]); MULADD(at[4], at[13]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); MULADD(at[4], at[14]); MULADD(at[5], at[13]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); MULADD(at[6], at[13]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); MULADD(at[7], at[13]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); MULADD(at[8], at[13]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); MULADD(at[9], at[13]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); MULADD(at[10], at[13]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); MULADD(at[11], at[13]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); MULADD(at[10], at[15]); MULADD(at[11], at[14]); MULADD(at[12], at[13]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + 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]); MULADD(at[11], at[15]); MULADD(at[12], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[12], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[9], at[25]); MULADD(at[10], at[24]); MULADD(at[11], at[23]); MULADD(at[12], at[22]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[10], at[25]); MULADD(at[11], at[24]); MULADD(at[12], at[23]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[11], at[25]); MULADD(at[12], at[24]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[12], at[25]); + COMBA_STORE(C->dp[24]); + COMBA_STORE2(C->dp[25]); + C->used = 26; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 14: + memcpy(at, A->dp, 14 * sizeof(fp_digit)); + memcpy(at+14, B->dp, 14 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[14]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[15]); MULADD(at[1], at[14]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); MULADD(at[2], at[14]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); MULADD(at[3], at[14]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); MULADD(at[4], at[14]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); MULADD(at[5], at[14]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); MULADD(at[5], at[15]); MULADD(at[6], at[14]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); MULADD(at[6], at[15]); MULADD(at[7], at[14]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[7], at[15]); MULADD(at[8], at[14]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[8], at[15]); MULADD(at[9], at[14]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[9], at[15]); MULADD(at[10], at[14]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[10], at[15]); MULADD(at[11], at[14]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); MULADD(at[11], at[15]); MULADD(at[12], at[14]); + COMBA_STORE(C->dp[12]); + /* 13 */ + 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]); MULADD(at[12], at[15]); MULADD(at[13], at[14]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + 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]); MULADD(at[13], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[10], at[27]); MULADD(at[11], at[26]); MULADD(at[12], at[25]); MULADD(at[13], at[24]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[11], at[27]); MULADD(at[12], at[26]); MULADD(at[13], at[25]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[12], at[27]); MULADD(at[13], at[26]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[13], at[27]); + COMBA_STORE(C->dp[26]); + COMBA_STORE2(C->dp[27]); + C->used = 28; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 15: + memcpy(at, A->dp, 15 * sizeof(fp_digit)); + memcpy(at+15, B->dp, 15 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[15]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[16]); MULADD(at[1], at[15]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[17]); MULADD(at[1], at[16]); MULADD(at[2], at[15]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]); MULADD(at[3], at[15]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]); MULADD(at[4], at[15]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); MULADD(at[5], at[15]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); MULADD(at[6], at[15]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); MULADD(at[7], at[15]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); MULADD(at[8], at[15]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); MULADD(at[9], at[15]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); MULADD(at[10], at[15]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); MULADD(at[11], at[15]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); MULADD(at[12], at[15]); + COMBA_STORE(C->dp[12]); + /* 13 */ + 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]); MULADD(at[13], at[15]); + COMBA_STORE(C->dp[13]); + /* 14 */ + 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]); MULADD(at[14], at[15]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + 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[15]); + /* 16 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + 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]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[11], at[29]); MULADD(at[12], at[28]); MULADD(at[13], at[27]); MULADD(at[14], at[26]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[12], at[29]); MULADD(at[13], at[28]); MULADD(at[14], at[27]); + COMBA_STORE(C->dp[26]); + /* 27 */ + COMBA_FORWARD; + MULADD(at[13], at[29]); MULADD(at[14], at[28]); + COMBA_STORE(C->dp[27]); + /* 28 */ + COMBA_FORWARD; + MULADD(at[14], at[29]); + COMBA_STORE(C->dp[28]); + COMBA_STORE2(C->dp[29]); + C->used = 30; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; + break; + + case 16: + memcpy(at, A->dp, 16 * sizeof(fp_digit)); + memcpy(at+16, B->dp, 16 * sizeof(fp_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; + fp_clamp(C); + COMBA_FINI; + break; + } } -#endif /* TFM_LARGE */ +#endif #ifdef TFM_HUGE @@ -2730,8 +3989,932 @@ void fp_mul_comba32(fp_int *A, fp_int *B, fp_int *C) COMBA_FINI; } +void fp_mul_comba64(fp_int *A, fp_int *B, fp_int *C) +{ + fp_digit c0, c1, c2, at[128]; + + memcpy(at, A->dp, 64 * sizeof(fp_digit)); + memcpy(at+64, B->dp, 64 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[64]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[65]); MULADD(at[1], at[64]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[66]); MULADD(at[1], at[65]); MULADD(at[2], at[64]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[67]); MULADD(at[1], at[66]); MULADD(at[2], at[65]); MULADD(at[3], at[64]); + COMBA_STORE(C->dp[3]); + /* 4 */ + COMBA_FORWARD; + MULADD(at[0], at[68]); MULADD(at[1], at[67]); MULADD(at[2], at[66]); MULADD(at[3], at[65]); MULADD(at[4], at[64]); + COMBA_STORE(C->dp[4]); + /* 5 */ + COMBA_FORWARD; + MULADD(at[0], at[69]); MULADD(at[1], at[68]); MULADD(at[2], at[67]); MULADD(at[3], at[66]); MULADD(at[4], at[65]); MULADD(at[5], at[64]); + COMBA_STORE(C->dp[5]); + /* 6 */ + COMBA_FORWARD; + MULADD(at[0], at[70]); MULADD(at[1], at[69]); MULADD(at[2], at[68]); MULADD(at[3], at[67]); MULADD(at[4], at[66]); MULADD(at[5], at[65]); MULADD(at[6], at[64]); + COMBA_STORE(C->dp[6]); + /* 7 */ + COMBA_FORWARD; + MULADD(at[0], at[71]); MULADD(at[1], at[70]); MULADD(at[2], at[69]); MULADD(at[3], at[68]); MULADD(at[4], at[67]); MULADD(at[5], at[66]); MULADD(at[6], at[65]); MULADD(at[7], at[64]); + COMBA_STORE(C->dp[7]); + /* 8 */ + COMBA_FORWARD; + MULADD(at[0], at[72]); MULADD(at[1], at[71]); MULADD(at[2], at[70]); MULADD(at[3], at[69]); MULADD(at[4], at[68]); MULADD(at[5], at[67]); MULADD(at[6], at[66]); MULADD(at[7], at[65]); MULADD(at[8], at[64]); + COMBA_STORE(C->dp[8]); + /* 9 */ + COMBA_FORWARD; + MULADD(at[0], at[73]); MULADD(at[1], at[72]); MULADD(at[2], at[71]); MULADD(at[3], at[70]); MULADD(at[4], at[69]); MULADD(at[5], at[68]); MULADD(at[6], at[67]); MULADD(at[7], at[66]); MULADD(at[8], at[65]); MULADD(at[9], at[64]); + COMBA_STORE(C->dp[9]); + /* 10 */ + COMBA_FORWARD; + MULADD(at[0], at[74]); MULADD(at[1], at[73]); MULADD(at[2], at[72]); MULADD(at[3], at[71]); MULADD(at[4], at[70]); MULADD(at[5], at[69]); MULADD(at[6], at[68]); MULADD(at[7], at[67]); MULADD(at[8], at[66]); MULADD(at[9], at[65]); MULADD(at[10], at[64]); + COMBA_STORE(C->dp[10]); + /* 11 */ + COMBA_FORWARD; + MULADD(at[0], at[75]); MULADD(at[1], at[74]); MULADD(at[2], at[73]); MULADD(at[3], at[72]); MULADD(at[4], at[71]); MULADD(at[5], at[70]); MULADD(at[6], at[69]); MULADD(at[7], at[68]); MULADD(at[8], at[67]); MULADD(at[9], at[66]); MULADD(at[10], at[65]); MULADD(at[11], at[64]); + COMBA_STORE(C->dp[11]); + /* 12 */ + COMBA_FORWARD; + MULADD(at[0], at[76]); MULADD(at[1], at[75]); MULADD(at[2], at[74]); MULADD(at[3], at[73]); MULADD(at[4], at[72]); MULADD(at[5], at[71]); MULADD(at[6], at[70]); MULADD(at[7], at[69]); MULADD(at[8], at[68]); MULADD(at[9], at[67]); MULADD(at[10], at[66]); MULADD(at[11], at[65]); MULADD(at[12], at[64]); + COMBA_STORE(C->dp[12]); + /* 13 */ + COMBA_FORWARD; + MULADD(at[0], at[77]); MULADD(at[1], at[76]); MULADD(at[2], at[75]); MULADD(at[3], at[74]); MULADD(at[4], at[73]); MULADD(at[5], at[72]); MULADD(at[6], at[71]); MULADD(at[7], at[70]); MULADD(at[8], at[69]); MULADD(at[9], at[68]); MULADD(at[10], at[67]); MULADD(at[11], at[66]); MULADD(at[12], at[65]); MULADD(at[13], at[64]); + COMBA_STORE(C->dp[13]); + /* 14 */ + COMBA_FORWARD; + MULADD(at[0], at[78]); MULADD(at[1], at[77]); MULADD(at[2], at[76]); MULADD(at[3], at[75]); MULADD(at[4], at[74]); MULADD(at[5], at[73]); MULADD(at[6], at[72]); MULADD(at[7], at[71]); MULADD(at[8], at[70]); MULADD(at[9], at[69]); MULADD(at[10], at[68]); MULADD(at[11], at[67]); MULADD(at[12], at[66]); MULADD(at[13], at[65]); MULADD(at[14], at[64]); + COMBA_STORE(C->dp[14]); + /* 15 */ + COMBA_FORWARD; + MULADD(at[0], at[79]); MULADD(at[1], at[78]); MULADD(at[2], at[77]); MULADD(at[3], at[76]); MULADD(at[4], at[75]); MULADD(at[5], at[74]); MULADD(at[6], at[73]); MULADD(at[7], at[72]); MULADD(at[8], at[71]); MULADD(at[9], at[70]); MULADD(at[10], at[69]); MULADD(at[11], at[68]); MULADD(at[12], at[67]); MULADD(at[13], at[66]); MULADD(at[14], at[65]); MULADD(at[15], at[64]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[0], at[80]); MULADD(at[1], at[79]); MULADD(at[2], at[78]); MULADD(at[3], at[77]); MULADD(at[4], at[76]); MULADD(at[5], at[75]); MULADD(at[6], at[74]); MULADD(at[7], at[73]); MULADD(at[8], at[72]); MULADD(at[9], at[71]); MULADD(at[10], at[70]); MULADD(at[11], at[69]); MULADD(at[12], at[68]); MULADD(at[13], at[67]); MULADD(at[14], at[66]); MULADD(at[15], at[65]); MULADD(at[16], at[64]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[0], at[81]); MULADD(at[1], at[80]); MULADD(at[2], at[79]); MULADD(at[3], at[78]); MULADD(at[4], at[77]); MULADD(at[5], at[76]); MULADD(at[6], at[75]); MULADD(at[7], at[74]); MULADD(at[8], at[73]); MULADD(at[9], at[72]); MULADD(at[10], at[71]); MULADD(at[11], at[70]); MULADD(at[12], at[69]); MULADD(at[13], at[68]); MULADD(at[14], at[67]); MULADD(at[15], at[66]); MULADD(at[16], at[65]); MULADD(at[17], at[64]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[0], at[82]); MULADD(at[1], at[81]); MULADD(at[2], at[80]); MULADD(at[3], at[79]); MULADD(at[4], at[78]); MULADD(at[5], at[77]); MULADD(at[6], at[76]); MULADD(at[7], at[75]); MULADD(at[8], at[74]); MULADD(at[9], at[73]); MULADD(at[10], at[72]); MULADD(at[11], at[71]); MULADD(at[12], at[70]); MULADD(at[13], at[69]); MULADD(at[14], at[68]); MULADD(at[15], at[67]); MULADD(at[16], at[66]); MULADD(at[17], at[65]); MULADD(at[18], at[64]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[0], at[83]); MULADD(at[1], at[82]); MULADD(at[2], at[81]); MULADD(at[3], at[80]); MULADD(at[4], at[79]); MULADD(at[5], at[78]); MULADD(at[6], at[77]); MULADD(at[7], at[76]); MULADD(at[8], at[75]); MULADD(at[9], at[74]); MULADD(at[10], at[73]); MULADD(at[11], at[72]); MULADD(at[12], at[71]); MULADD(at[13], at[70]); MULADD(at[14], at[69]); MULADD(at[15], at[68]); MULADD(at[16], at[67]); MULADD(at[17], at[66]); MULADD(at[18], at[65]); MULADD(at[19], at[64]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[0], at[84]); MULADD(at[1], at[83]); MULADD(at[2], at[82]); MULADD(at[3], at[81]); MULADD(at[4], at[80]); MULADD(at[5], at[79]); MULADD(at[6], at[78]); MULADD(at[7], at[77]); MULADD(at[8], at[76]); MULADD(at[9], at[75]); MULADD(at[10], at[74]); MULADD(at[11], at[73]); MULADD(at[12], at[72]); MULADD(at[13], at[71]); MULADD(at[14], at[70]); MULADD(at[15], at[69]); MULADD(at[16], at[68]); MULADD(at[17], at[67]); MULADD(at[18], at[66]); MULADD(at[19], at[65]); MULADD(at[20], at[64]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[0], at[85]); MULADD(at[1], at[84]); MULADD(at[2], at[83]); MULADD(at[3], at[82]); MULADD(at[4], at[81]); MULADD(at[5], at[80]); MULADD(at[6], at[79]); MULADD(at[7], at[78]); MULADD(at[8], at[77]); MULADD(at[9], at[76]); MULADD(at[10], at[75]); MULADD(at[11], at[74]); MULADD(at[12], at[73]); MULADD(at[13], at[72]); MULADD(at[14], at[71]); MULADD(at[15], at[70]); MULADD(at[16], at[69]); MULADD(at[17], at[68]); MULADD(at[18], at[67]); MULADD(at[19], at[66]); MULADD(at[20], at[65]); MULADD(at[21], at[64]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[0], at[86]); MULADD(at[1], at[85]); MULADD(at[2], at[84]); MULADD(at[3], at[83]); MULADD(at[4], at[82]); MULADD(at[5], at[81]); MULADD(at[6], at[80]); MULADD(at[7], at[79]); MULADD(at[8], at[78]); MULADD(at[9], at[77]); MULADD(at[10], at[76]); MULADD(at[11], at[75]); MULADD(at[12], at[74]); MULADD(at[13], at[73]); MULADD(at[14], at[72]); MULADD(at[15], at[71]); MULADD(at[16], at[70]); MULADD(at[17], at[69]); MULADD(at[18], at[68]); MULADD(at[19], at[67]); MULADD(at[20], at[66]); MULADD(at[21], at[65]); MULADD(at[22], at[64]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[0], at[87]); MULADD(at[1], at[86]); MULADD(at[2], at[85]); MULADD(at[3], at[84]); MULADD(at[4], at[83]); MULADD(at[5], at[82]); MULADD(at[6], at[81]); MULADD(at[7], at[80]); MULADD(at[8], at[79]); MULADD(at[9], at[78]); MULADD(at[10], at[77]); MULADD(at[11], at[76]); MULADD(at[12], at[75]); MULADD(at[13], at[74]); MULADD(at[14], at[73]); MULADD(at[15], at[72]); MULADD(at[16], at[71]); MULADD(at[17], at[70]); MULADD(at[18], at[69]); MULADD(at[19], at[68]); MULADD(at[20], at[67]); MULADD(at[21], at[66]); MULADD(at[22], at[65]); MULADD(at[23], at[64]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[0], at[88]); MULADD(at[1], at[87]); MULADD(at[2], at[86]); MULADD(at[3], at[85]); MULADD(at[4], at[84]); MULADD(at[5], at[83]); MULADD(at[6], at[82]); MULADD(at[7], at[81]); MULADD(at[8], at[80]); MULADD(at[9], at[79]); MULADD(at[10], at[78]); MULADD(at[11], at[77]); MULADD(at[12], at[76]); MULADD(at[13], at[75]); MULADD(at[14], at[74]); MULADD(at[15], at[73]); MULADD(at[16], at[72]); MULADD(at[17], at[71]); MULADD(at[18], at[70]); MULADD(at[19], at[69]); MULADD(at[20], at[68]); MULADD(at[21], at[67]); MULADD(at[22], at[66]); MULADD(at[23], at[65]); MULADD(at[24], at[64]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[0], at[89]); MULADD(at[1], at[88]); MULADD(at[2], at[87]); MULADD(at[3], at[86]); MULADD(at[4], at[85]); MULADD(at[5], at[84]); MULADD(at[6], at[83]); MULADD(at[7], at[82]); MULADD(at[8], at[81]); MULADD(at[9], at[80]); MULADD(at[10], at[79]); MULADD(at[11], at[78]); MULADD(at[12], at[77]); MULADD(at[13], at[76]); MULADD(at[14], at[75]); MULADD(at[15], at[74]); MULADD(at[16], at[73]); MULADD(at[17], at[72]); MULADD(at[18], at[71]); MULADD(at[19], at[70]); MULADD(at[20], at[69]); MULADD(at[21], at[68]); MULADD(at[22], at[67]); MULADD(at[23], at[66]); MULADD(at[24], at[65]); MULADD(at[25], at[64]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[0], at[90]); MULADD(at[1], at[89]); MULADD(at[2], at[88]); MULADD(at[3], at[87]); MULADD(at[4], at[86]); MULADD(at[5], at[85]); MULADD(at[6], at[84]); MULADD(at[7], at[83]); MULADD(at[8], at[82]); MULADD(at[9], at[81]); MULADD(at[10], at[80]); MULADD(at[11], at[79]); MULADD(at[12], at[78]); MULADD(at[13], at[77]); MULADD(at[14], at[76]); MULADD(at[15], at[75]); MULADD(at[16], at[74]); MULADD(at[17], at[73]); MULADD(at[18], at[72]); MULADD(at[19], at[71]); MULADD(at[20], at[70]); MULADD(at[21], at[69]); MULADD(at[22], at[68]); MULADD(at[23], at[67]); MULADD(at[24], at[66]); MULADD(at[25], at[65]); MULADD(at[26], at[64]); + COMBA_STORE(C->dp[26]); + /* 27 */ + COMBA_FORWARD; + MULADD(at[0], at[91]); MULADD(at[1], at[90]); MULADD(at[2], at[89]); MULADD(at[3], at[88]); MULADD(at[4], at[87]); MULADD(at[5], at[86]); MULADD(at[6], at[85]); MULADD(at[7], at[84]); MULADD(at[8], at[83]); MULADD(at[9], at[82]); MULADD(at[10], at[81]); MULADD(at[11], at[80]); MULADD(at[12], at[79]); MULADD(at[13], at[78]); MULADD(at[14], at[77]); MULADD(at[15], at[76]); MULADD(at[16], at[75]); MULADD(at[17], at[74]); MULADD(at[18], at[73]); MULADD(at[19], at[72]); MULADD(at[20], at[71]); MULADD(at[21], at[70]); MULADD(at[22], at[69]); MULADD(at[23], at[68]); MULADD(at[24], at[67]); MULADD(at[25], at[66]); MULADD(at[26], at[65]); MULADD(at[27], at[64]); + COMBA_STORE(C->dp[27]); + /* 28 */ + COMBA_FORWARD; + MULADD(at[0], at[92]); MULADD(at[1], at[91]); MULADD(at[2], at[90]); MULADD(at[3], at[89]); MULADD(at[4], at[88]); MULADD(at[5], at[87]); MULADD(at[6], at[86]); MULADD(at[7], at[85]); MULADD(at[8], at[84]); MULADD(at[9], at[83]); MULADD(at[10], at[82]); MULADD(at[11], at[81]); MULADD(at[12], at[80]); MULADD(at[13], at[79]); MULADD(at[14], at[78]); MULADD(at[15], at[77]); MULADD(at[16], at[76]); MULADD(at[17], at[75]); MULADD(at[18], at[74]); MULADD(at[19], at[73]); MULADD(at[20], at[72]); MULADD(at[21], at[71]); MULADD(at[22], at[70]); MULADD(at[23], at[69]); MULADD(at[24], at[68]); MULADD(at[25], at[67]); MULADD(at[26], at[66]); MULADD(at[27], at[65]); MULADD(at[28], at[64]); + COMBA_STORE(C->dp[28]); + /* 29 */ + COMBA_FORWARD; + MULADD(at[0], at[93]); MULADD(at[1], at[92]); MULADD(at[2], at[91]); MULADD(at[3], at[90]); MULADD(at[4], at[89]); MULADD(at[5], at[88]); MULADD(at[6], at[87]); MULADD(at[7], at[86]); MULADD(at[8], at[85]); MULADD(at[9], at[84]); MULADD(at[10], at[83]); MULADD(at[11], at[82]); MULADD(at[12], at[81]); MULADD(at[13], at[80]); MULADD(at[14], at[79]); MULADD(at[15], at[78]); MULADD(at[16], at[77]); MULADD(at[17], at[76]); MULADD(at[18], at[75]); MULADD(at[19], at[74]); MULADD(at[20], at[73]); MULADD(at[21], at[72]); MULADD(at[22], at[71]); MULADD(at[23], at[70]); MULADD(at[24], at[69]); MULADD(at[25], at[68]); MULADD(at[26], at[67]); MULADD(at[27], at[66]); MULADD(at[28], at[65]); MULADD(at[29], at[64]); + COMBA_STORE(C->dp[29]); + /* 30 */ + COMBA_FORWARD; + MULADD(at[0], at[94]); MULADD(at[1], at[93]); MULADD(at[2], at[92]); MULADD(at[3], at[91]); MULADD(at[4], at[90]); MULADD(at[5], at[89]); MULADD(at[6], at[88]); MULADD(at[7], at[87]); MULADD(at[8], at[86]); MULADD(at[9], at[85]); MULADD(at[10], at[84]); MULADD(at[11], at[83]); MULADD(at[12], at[82]); MULADD(at[13], at[81]); MULADD(at[14], at[80]); MULADD(at[15], at[79]); MULADD(at[16], at[78]); MULADD(at[17], at[77]); MULADD(at[18], at[76]); MULADD(at[19], at[75]); MULADD(at[20], at[74]); MULADD(at[21], at[73]); MULADD(at[22], at[72]); MULADD(at[23], at[71]); MULADD(at[24], at[70]); MULADD(at[25], at[69]); MULADD(at[26], at[68]); MULADD(at[27], at[67]); MULADD(at[28], at[66]); MULADD(at[29], at[65]); MULADD(at[30], at[64]); + COMBA_STORE(C->dp[30]); + /* 31 */ + COMBA_FORWARD; + MULADD(at[0], at[95]); MULADD(at[1], at[94]); MULADD(at[2], at[93]); MULADD(at[3], at[92]); MULADD(at[4], at[91]); MULADD(at[5], at[90]); MULADD(at[6], at[89]); MULADD(at[7], at[88]); MULADD(at[8], at[87]); MULADD(at[9], at[86]); MULADD(at[10], at[85]); MULADD(at[11], at[84]); MULADD(at[12], at[83]); MULADD(at[13], at[82]); MULADD(at[14], at[81]); MULADD(at[15], at[80]); MULADD(at[16], at[79]); MULADD(at[17], at[78]); MULADD(at[18], at[77]); MULADD(at[19], at[76]); MULADD(at[20], at[75]); MULADD(at[21], at[74]); MULADD(at[22], at[73]); MULADD(at[23], at[72]); MULADD(at[24], at[71]); MULADD(at[25], at[70]); MULADD(at[26], at[69]); MULADD(at[27], at[68]); MULADD(at[28], at[67]); MULADD(at[29], at[66]); MULADD(at[30], at[65]); MULADD(at[31], at[64]); + COMBA_STORE(C->dp[31]); + /* 32 */ + COMBA_FORWARD; + MULADD(at[0], at[96]); MULADD(at[1], at[95]); MULADD(at[2], at[94]); MULADD(at[3], at[93]); MULADD(at[4], at[92]); MULADD(at[5], at[91]); MULADD(at[6], at[90]); MULADD(at[7], at[89]); MULADD(at[8], at[88]); MULADD(at[9], at[87]); MULADD(at[10], at[86]); MULADD(at[11], at[85]); MULADD(at[12], at[84]); MULADD(at[13], at[83]); MULADD(at[14], at[82]); MULADD(at[15], at[81]); MULADD(at[16], at[80]); MULADD(at[17], at[79]); MULADD(at[18], at[78]); MULADD(at[19], at[77]); MULADD(at[20], at[76]); MULADD(at[21], at[75]); MULADD(at[22], at[74]); MULADD(at[23], at[73]); MULADD(at[24], at[72]); MULADD(at[25], at[71]); MULADD(at[26], at[70]); MULADD(at[27], at[69]); MULADD(at[28], at[68]); MULADD(at[29], at[67]); MULADD(at[30], at[66]); MULADD(at[31], at[65]); MULADD(at[32], at[64]); + COMBA_STORE(C->dp[32]); + /* 33 */ + COMBA_FORWARD; + MULADD(at[0], at[97]); MULADD(at[1], at[96]); MULADD(at[2], at[95]); MULADD(at[3], at[94]); MULADD(at[4], at[93]); MULADD(at[5], at[92]); MULADD(at[6], at[91]); MULADD(at[7], at[90]); MULADD(at[8], at[89]); MULADD(at[9], at[88]); MULADD(at[10], at[87]); MULADD(at[11], at[86]); MULADD(at[12], at[85]); MULADD(at[13], at[84]); MULADD(at[14], at[83]); MULADD(at[15], at[82]); MULADD(at[16], at[81]); MULADD(at[17], at[80]); MULADD(at[18], at[79]); MULADD(at[19], at[78]); MULADD(at[20], at[77]); MULADD(at[21], at[76]); MULADD(at[22], at[75]); MULADD(at[23], at[74]); MULADD(at[24], at[73]); MULADD(at[25], at[72]); MULADD(at[26], at[71]); MULADD(at[27], at[70]); MULADD(at[28], at[69]); MULADD(at[29], at[68]); MULADD(at[30], at[67]); MULADD(at[31], at[66]); MULADD(at[32], at[65]); MULADD(at[33], at[64]); + COMBA_STORE(C->dp[33]); + /* 34 */ + COMBA_FORWARD; + MULADD(at[0], at[98]); MULADD(at[1], at[97]); MULADD(at[2], at[96]); MULADD(at[3], at[95]); MULADD(at[4], at[94]); MULADD(at[5], at[93]); MULADD(at[6], at[92]); MULADD(at[7], at[91]); MULADD(at[8], at[90]); MULADD(at[9], at[89]); MULADD(at[10], at[88]); MULADD(at[11], at[87]); MULADD(at[12], at[86]); MULADD(at[13], at[85]); MULADD(at[14], at[84]); MULADD(at[15], at[83]); MULADD(at[16], at[82]); MULADD(at[17], at[81]); MULADD(at[18], at[80]); MULADD(at[19], at[79]); MULADD(at[20], at[78]); MULADD(at[21], at[77]); MULADD(at[22], at[76]); MULADD(at[23], at[75]); MULADD(at[24], at[74]); MULADD(at[25], at[73]); MULADD(at[26], at[72]); MULADD(at[27], at[71]); MULADD(at[28], at[70]); MULADD(at[29], at[69]); MULADD(at[30], at[68]); MULADD(at[31], at[67]); MULADD(at[32], at[66]); MULADD(at[33], at[65]); MULADD(at[34], at[64]); + COMBA_STORE(C->dp[34]); + /* 35 */ + COMBA_FORWARD; + MULADD(at[0], at[99]); MULADD(at[1], at[98]); MULADD(at[2], at[97]); MULADD(at[3], at[96]); MULADD(at[4], at[95]); MULADD(at[5], at[94]); MULADD(at[6], at[93]); MULADD(at[7], at[92]); MULADD(at[8], at[91]); MULADD(at[9], at[90]); MULADD(at[10], at[89]); MULADD(at[11], at[88]); MULADD(at[12], at[87]); MULADD(at[13], at[86]); MULADD(at[14], at[85]); MULADD(at[15], at[84]); MULADD(at[16], at[83]); MULADD(at[17], at[82]); MULADD(at[18], at[81]); MULADD(at[19], at[80]); MULADD(at[20], at[79]); MULADD(at[21], at[78]); MULADD(at[22], at[77]); MULADD(at[23], at[76]); MULADD(at[24], at[75]); MULADD(at[25], at[74]); MULADD(at[26], at[73]); MULADD(at[27], at[72]); MULADD(at[28], at[71]); MULADD(at[29], at[70]); MULADD(at[30], at[69]); MULADD(at[31], at[68]); MULADD(at[32], at[67]); MULADD(at[33], at[66]); MULADD(at[34], at[65]); MULADD(at[35], at[64]); + COMBA_STORE(C->dp[35]); + /* 36 */ + COMBA_FORWARD; + MULADD(at[0], at[100]); MULADD(at[1], at[99]); MULADD(at[2], at[98]); MULADD(at[3], at[97]); MULADD(at[4], at[96]); MULADD(at[5], at[95]); MULADD(at[6], at[94]); MULADD(at[7], at[93]); MULADD(at[8], at[92]); MULADD(at[9], at[91]); MULADD(at[10], at[90]); MULADD(at[11], at[89]); MULADD(at[12], at[88]); MULADD(at[13], at[87]); MULADD(at[14], at[86]); MULADD(at[15], at[85]); MULADD(at[16], at[84]); MULADD(at[17], at[83]); MULADD(at[18], at[82]); MULADD(at[19], at[81]); MULADD(at[20], at[80]); MULADD(at[21], at[79]); MULADD(at[22], at[78]); MULADD(at[23], at[77]); MULADD(at[24], at[76]); MULADD(at[25], at[75]); MULADD(at[26], at[74]); MULADD(at[27], at[73]); MULADD(at[28], at[72]); MULADD(at[29], at[71]); MULADD(at[30], at[70]); MULADD(at[31], at[69]); MULADD(at[32], at[68]); MULADD(at[33], at[67]); MULADD(at[34], at[66]); MULADD(at[35], at[65]); MULADD(at[36], at[64]); + COMBA_STORE(C->dp[36]); + /* 37 */ + COMBA_FORWARD; + MULADD(at[0], at[101]); MULADD(at[1], at[100]); MULADD(at[2], at[99]); MULADD(at[3], at[98]); MULADD(at[4], at[97]); MULADD(at[5], at[96]); MULADD(at[6], at[95]); MULADD(at[7], at[94]); MULADD(at[8], at[93]); MULADD(at[9], at[92]); MULADD(at[10], at[91]); MULADD(at[11], at[90]); MULADD(at[12], at[89]); MULADD(at[13], at[88]); MULADD(at[14], at[87]); MULADD(at[15], at[86]); MULADD(at[16], at[85]); MULADD(at[17], at[84]); MULADD(at[18], at[83]); MULADD(at[19], at[82]); MULADD(at[20], at[81]); MULADD(at[21], at[80]); MULADD(at[22], at[79]); MULADD(at[23], at[78]); MULADD(at[24], at[77]); MULADD(at[25], at[76]); MULADD(at[26], at[75]); MULADD(at[27], at[74]); MULADD(at[28], at[73]); MULADD(at[29], at[72]); MULADD(at[30], at[71]); MULADD(at[31], at[70]); MULADD(at[32], at[69]); MULADD(at[33], at[68]); MULADD(at[34], at[67]); MULADD(at[35], at[66]); MULADD(at[36], at[65]); MULADD(at[37], at[64]); + COMBA_STORE(C->dp[37]); + /* 38 */ + COMBA_FORWARD; + MULADD(at[0], at[102]); MULADD(at[1], at[101]); MULADD(at[2], at[100]); MULADD(at[3], at[99]); MULADD(at[4], at[98]); MULADD(at[5], at[97]); MULADD(at[6], at[96]); MULADD(at[7], at[95]); MULADD(at[8], at[94]); MULADD(at[9], at[93]); MULADD(at[10], at[92]); MULADD(at[11], at[91]); MULADD(at[12], at[90]); MULADD(at[13], at[89]); MULADD(at[14], at[88]); MULADD(at[15], at[87]); MULADD(at[16], at[86]); MULADD(at[17], at[85]); MULADD(at[18], at[84]); MULADD(at[19], at[83]); MULADD(at[20], at[82]); MULADD(at[21], at[81]); MULADD(at[22], at[80]); MULADD(at[23], at[79]); MULADD(at[24], at[78]); MULADD(at[25], at[77]); MULADD(at[26], at[76]); MULADD(at[27], at[75]); MULADD(at[28], at[74]); MULADD(at[29], at[73]); MULADD(at[30], at[72]); MULADD(at[31], at[71]); MULADD(at[32], at[70]); MULADD(at[33], at[69]); MULADD(at[34], at[68]); MULADD(at[35], at[67]); MULADD(at[36], at[66]); MULADD(at[37], at[65]); MULADD(at[38], at[64]); + COMBA_STORE(C->dp[38]); + /* 39 */ + COMBA_FORWARD; + MULADD(at[0], at[103]); MULADD(at[1], at[102]); MULADD(at[2], at[101]); MULADD(at[3], at[100]); MULADD(at[4], at[99]); MULADD(at[5], at[98]); MULADD(at[6], at[97]); MULADD(at[7], at[96]); MULADD(at[8], at[95]); MULADD(at[9], at[94]); MULADD(at[10], at[93]); MULADD(at[11], at[92]); MULADD(at[12], at[91]); MULADD(at[13], at[90]); MULADD(at[14], at[89]); MULADD(at[15], at[88]); MULADD(at[16], at[87]); MULADD(at[17], at[86]); MULADD(at[18], at[85]); MULADD(at[19], at[84]); MULADD(at[20], at[83]); MULADD(at[21], at[82]); MULADD(at[22], at[81]); MULADD(at[23], at[80]); MULADD(at[24], at[79]); MULADD(at[25], at[78]); MULADD(at[26], at[77]); MULADD(at[27], at[76]); MULADD(at[28], at[75]); MULADD(at[29], at[74]); MULADD(at[30], at[73]); MULADD(at[31], at[72]); MULADD(at[32], at[71]); MULADD(at[33], at[70]); MULADD(at[34], at[69]); MULADD(at[35], at[68]); MULADD(at[36], at[67]); MULADD(at[37], at[66]); MULADD(at[38], at[65]); MULADD(at[39], at[64]); + COMBA_STORE(C->dp[39]); + /* 40 */ + COMBA_FORWARD; + MULADD(at[0], at[104]); MULADD(at[1], at[103]); MULADD(at[2], at[102]); MULADD(at[3], at[101]); MULADD(at[4], at[100]); MULADD(at[5], at[99]); MULADD(at[6], at[98]); MULADD(at[7], at[97]); MULADD(at[8], at[96]); MULADD(at[9], at[95]); MULADD(at[10], at[94]); MULADD(at[11], at[93]); MULADD(at[12], at[92]); MULADD(at[13], at[91]); MULADD(at[14], at[90]); MULADD(at[15], at[89]); MULADD(at[16], at[88]); MULADD(at[17], at[87]); MULADD(at[18], at[86]); MULADD(at[19], at[85]); MULADD(at[20], at[84]); MULADD(at[21], at[83]); MULADD(at[22], at[82]); MULADD(at[23], at[81]); MULADD(at[24], at[80]); MULADD(at[25], at[79]); MULADD(at[26], at[78]); MULADD(at[27], at[77]); MULADD(at[28], at[76]); MULADD(at[29], at[75]); MULADD(at[30], at[74]); MULADD(at[31], at[73]); MULADD(at[32], at[72]); MULADD(at[33], at[71]); MULADD(at[34], at[70]); MULADD(at[35], at[69]); MULADD(at[36], at[68]); MULADD(at[37], at[67]); MULADD(at[38], at[66]); MULADD(at[39], at[65]); MULADD(at[40], at[64]); + COMBA_STORE(C->dp[40]); + /* 41 */ + COMBA_FORWARD; + MULADD(at[0], at[105]); MULADD(at[1], at[104]); MULADD(at[2], at[103]); MULADD(at[3], at[102]); MULADD(at[4], at[101]); MULADD(at[5], at[100]); MULADD(at[6], at[99]); MULADD(at[7], at[98]); MULADD(at[8], at[97]); MULADD(at[9], at[96]); MULADD(at[10], at[95]); MULADD(at[11], at[94]); MULADD(at[12], at[93]); MULADD(at[13], at[92]); MULADD(at[14], at[91]); MULADD(at[15], at[90]); MULADD(at[16], at[89]); MULADD(at[17], at[88]); MULADD(at[18], at[87]); MULADD(at[19], at[86]); MULADD(at[20], at[85]); MULADD(at[21], at[84]); MULADD(at[22], at[83]); MULADD(at[23], at[82]); MULADD(at[24], at[81]); MULADD(at[25], at[80]); MULADD(at[26], at[79]); MULADD(at[27], at[78]); MULADD(at[28], at[77]); MULADD(at[29], at[76]); MULADD(at[30], at[75]); MULADD(at[31], at[74]); MULADD(at[32], at[73]); MULADD(at[33], at[72]); MULADD(at[34], at[71]); MULADD(at[35], at[70]); MULADD(at[36], at[69]); MULADD(at[37], at[68]); MULADD(at[38], at[67]); MULADD(at[39], at[66]); MULADD(at[40], at[65]); MULADD(at[41], at[64]); + COMBA_STORE(C->dp[41]); + /* 42 */ + COMBA_FORWARD; + MULADD(at[0], at[106]); MULADD(at[1], at[105]); MULADD(at[2], at[104]); MULADD(at[3], at[103]); MULADD(at[4], at[102]); MULADD(at[5], at[101]); MULADD(at[6], at[100]); MULADD(at[7], at[99]); MULADD(at[8], at[98]); MULADD(at[9], at[97]); MULADD(at[10], at[96]); MULADD(at[11], at[95]); MULADD(at[12], at[94]); MULADD(at[13], at[93]); MULADD(at[14], at[92]); MULADD(at[15], at[91]); MULADD(at[16], at[90]); MULADD(at[17], at[89]); MULADD(at[18], at[88]); MULADD(at[19], at[87]); MULADD(at[20], at[86]); MULADD(at[21], at[85]); MULADD(at[22], at[84]); MULADD(at[23], at[83]); MULADD(at[24], at[82]); MULADD(at[25], at[81]); MULADD(at[26], at[80]); MULADD(at[27], at[79]); MULADD(at[28], at[78]); MULADD(at[29], at[77]); MULADD(at[30], at[76]); MULADD(at[31], at[75]); MULADD(at[32], at[74]); MULADD(at[33], at[73]); MULADD(at[34], at[72]); MULADD(at[35], at[71]); MULADD(at[36], at[70]); MULADD(at[37], at[69]); MULADD(at[38], at[68]); MULADD(at[39], at[67]); MULADD(at[40], at[66]); MULADD(at[41], at[65]); MULADD(at[42], at[64]); + COMBA_STORE(C->dp[42]); + /* 43 */ + COMBA_FORWARD; + MULADD(at[0], at[107]); MULADD(at[1], at[106]); MULADD(at[2], at[105]); MULADD(at[3], at[104]); MULADD(at[4], at[103]); MULADD(at[5], at[102]); MULADD(at[6], at[101]); MULADD(at[7], at[100]); MULADD(at[8], at[99]); MULADD(at[9], at[98]); MULADD(at[10], at[97]); MULADD(at[11], at[96]); MULADD(at[12], at[95]); MULADD(at[13], at[94]); MULADD(at[14], at[93]); MULADD(at[15], at[92]); MULADD(at[16], at[91]); MULADD(at[17], at[90]); MULADD(at[18], at[89]); MULADD(at[19], at[88]); MULADD(at[20], at[87]); MULADD(at[21], at[86]); MULADD(at[22], at[85]); MULADD(at[23], at[84]); MULADD(at[24], at[83]); MULADD(at[25], at[82]); MULADD(at[26], at[81]); MULADD(at[27], at[80]); MULADD(at[28], at[79]); MULADD(at[29], at[78]); MULADD(at[30], at[77]); MULADD(at[31], at[76]); MULADD(at[32], at[75]); MULADD(at[33], at[74]); MULADD(at[34], at[73]); MULADD(at[35], at[72]); MULADD(at[36], at[71]); MULADD(at[37], at[70]); MULADD(at[38], at[69]); MULADD(at[39], at[68]); MULADD(at[40], at[67]); MULADD(at[41], at[66]); MULADD(at[42], at[65]); MULADD(at[43], at[64]); + COMBA_STORE(C->dp[43]); + /* 44 */ + COMBA_FORWARD; + MULADD(at[0], at[108]); MULADD(at[1], at[107]); MULADD(at[2], at[106]); MULADD(at[3], at[105]); MULADD(at[4], at[104]); MULADD(at[5], at[103]); MULADD(at[6], at[102]); MULADD(at[7], at[101]); MULADD(at[8], at[100]); MULADD(at[9], at[99]); MULADD(at[10], at[98]); MULADD(at[11], at[97]); MULADD(at[12], at[96]); MULADD(at[13], at[95]); MULADD(at[14], at[94]); MULADD(at[15], at[93]); MULADD(at[16], at[92]); MULADD(at[17], at[91]); MULADD(at[18], at[90]); MULADD(at[19], at[89]); MULADD(at[20], at[88]); MULADD(at[21], at[87]); MULADD(at[22], at[86]); MULADD(at[23], at[85]); MULADD(at[24], at[84]); MULADD(at[25], at[83]); MULADD(at[26], at[82]); MULADD(at[27], at[81]); MULADD(at[28], at[80]); MULADD(at[29], at[79]); MULADD(at[30], at[78]); MULADD(at[31], at[77]); MULADD(at[32], at[76]); MULADD(at[33], at[75]); MULADD(at[34], at[74]); MULADD(at[35], at[73]); MULADD(at[36], at[72]); MULADD(at[37], at[71]); MULADD(at[38], at[70]); MULADD(at[39], at[69]); MULADD(at[40], at[68]); MULADD(at[41], at[67]); MULADD(at[42], at[66]); MULADD(at[43], at[65]); MULADD(at[44], at[64]); + COMBA_STORE(C->dp[44]); + /* 45 */ + COMBA_FORWARD; + MULADD(at[0], at[109]); MULADD(at[1], at[108]); MULADD(at[2], at[107]); MULADD(at[3], at[106]); MULADD(at[4], at[105]); MULADD(at[5], at[104]); MULADD(at[6], at[103]); MULADD(at[7], at[102]); MULADD(at[8], at[101]); MULADD(at[9], at[100]); MULADD(at[10], at[99]); MULADD(at[11], at[98]); MULADD(at[12], at[97]); MULADD(at[13], at[96]); MULADD(at[14], at[95]); MULADD(at[15], at[94]); MULADD(at[16], at[93]); MULADD(at[17], at[92]); MULADD(at[18], at[91]); MULADD(at[19], at[90]); MULADD(at[20], at[89]); MULADD(at[21], at[88]); MULADD(at[22], at[87]); MULADD(at[23], at[86]); MULADD(at[24], at[85]); MULADD(at[25], at[84]); MULADD(at[26], at[83]); MULADD(at[27], at[82]); MULADD(at[28], at[81]); MULADD(at[29], at[80]); MULADD(at[30], at[79]); MULADD(at[31], at[78]); MULADD(at[32], at[77]); MULADD(at[33], at[76]); MULADD(at[34], at[75]); MULADD(at[35], at[74]); MULADD(at[36], at[73]); MULADD(at[37], at[72]); MULADD(at[38], at[71]); MULADD(at[39], at[70]); MULADD(at[40], at[69]); MULADD(at[41], at[68]); MULADD(at[42], at[67]); MULADD(at[43], at[66]); MULADD(at[44], at[65]); MULADD(at[45], at[64]); + COMBA_STORE(C->dp[45]); + /* 46 */ + COMBA_FORWARD; + MULADD(at[0], at[110]); MULADD(at[1], at[109]); MULADD(at[2], at[108]); MULADD(at[3], at[107]); MULADD(at[4], at[106]); MULADD(at[5], at[105]); MULADD(at[6], at[104]); MULADD(at[7], at[103]); MULADD(at[8], at[102]); MULADD(at[9], at[101]); MULADD(at[10], at[100]); MULADD(at[11], at[99]); MULADD(at[12], at[98]); MULADD(at[13], at[97]); MULADD(at[14], at[96]); MULADD(at[15], at[95]); MULADD(at[16], at[94]); MULADD(at[17], at[93]); MULADD(at[18], at[92]); MULADD(at[19], at[91]); MULADD(at[20], at[90]); MULADD(at[21], at[89]); MULADD(at[22], at[88]); MULADD(at[23], at[87]); MULADD(at[24], at[86]); MULADD(at[25], at[85]); MULADD(at[26], at[84]); MULADD(at[27], at[83]); MULADD(at[28], at[82]); MULADD(at[29], at[81]); MULADD(at[30], at[80]); MULADD(at[31], at[79]); MULADD(at[32], at[78]); MULADD(at[33], at[77]); MULADD(at[34], at[76]); MULADD(at[35], at[75]); MULADD(at[36], at[74]); MULADD(at[37], at[73]); MULADD(at[38], at[72]); MULADD(at[39], at[71]); MULADD(at[40], at[70]); MULADD(at[41], at[69]); MULADD(at[42], at[68]); MULADD(at[43], at[67]); MULADD(at[44], at[66]); MULADD(at[45], at[65]); MULADD(at[46], at[64]); + COMBA_STORE(C->dp[46]); + /* 47 */ + COMBA_FORWARD; + MULADD(at[0], at[111]); MULADD(at[1], at[110]); MULADD(at[2], at[109]); MULADD(at[3], at[108]); MULADD(at[4], at[107]); MULADD(at[5], at[106]); MULADD(at[6], at[105]); MULADD(at[7], at[104]); MULADD(at[8], at[103]); MULADD(at[9], at[102]); MULADD(at[10], at[101]); MULADD(at[11], at[100]); MULADD(at[12], at[99]); MULADD(at[13], at[98]); MULADD(at[14], at[97]); MULADD(at[15], at[96]); MULADD(at[16], at[95]); MULADD(at[17], at[94]); MULADD(at[18], at[93]); MULADD(at[19], at[92]); MULADD(at[20], at[91]); MULADD(at[21], at[90]); MULADD(at[22], at[89]); MULADD(at[23], at[88]); MULADD(at[24], at[87]); MULADD(at[25], at[86]); MULADD(at[26], at[85]); MULADD(at[27], at[84]); MULADD(at[28], at[83]); MULADD(at[29], at[82]); MULADD(at[30], at[81]); MULADD(at[31], at[80]); MULADD(at[32], at[79]); MULADD(at[33], at[78]); MULADD(at[34], at[77]); MULADD(at[35], at[76]); MULADD(at[36], at[75]); MULADD(at[37], at[74]); MULADD(at[38], at[73]); MULADD(at[39], at[72]); MULADD(at[40], at[71]); MULADD(at[41], at[70]); MULADD(at[42], at[69]); MULADD(at[43], at[68]); MULADD(at[44], at[67]); MULADD(at[45], at[66]); MULADD(at[46], at[65]); MULADD(at[47], at[64]); + COMBA_STORE(C->dp[47]); + /* 48 */ + COMBA_FORWARD; + MULADD(at[0], at[112]); MULADD(at[1], at[111]); MULADD(at[2], at[110]); MULADD(at[3], at[109]); MULADD(at[4], at[108]); MULADD(at[5], at[107]); MULADD(at[6], at[106]); MULADD(at[7], at[105]); MULADD(at[8], at[104]); MULADD(at[9], at[103]); MULADD(at[10], at[102]); MULADD(at[11], at[101]); MULADD(at[12], at[100]); MULADD(at[13], at[99]); MULADD(at[14], at[98]); MULADD(at[15], at[97]); MULADD(at[16], at[96]); MULADD(at[17], at[95]); MULADD(at[18], at[94]); MULADD(at[19], at[93]); MULADD(at[20], at[92]); MULADD(at[21], at[91]); MULADD(at[22], at[90]); MULADD(at[23], at[89]); MULADD(at[24], at[88]); MULADD(at[25], at[87]); MULADD(at[26], at[86]); MULADD(at[27], at[85]); MULADD(at[28], at[84]); MULADD(at[29], at[83]); MULADD(at[30], at[82]); MULADD(at[31], at[81]); MULADD(at[32], at[80]); MULADD(at[33], at[79]); MULADD(at[34], at[78]); MULADD(at[35], at[77]); MULADD(at[36], at[76]); MULADD(at[37], at[75]); MULADD(at[38], at[74]); MULADD(at[39], at[73]); MULADD(at[40], at[72]); MULADD(at[41], at[71]); MULADD(at[42], at[70]); MULADD(at[43], at[69]); MULADD(at[44], at[68]); MULADD(at[45], at[67]); MULADD(at[46], at[66]); MULADD(at[47], at[65]); MULADD(at[48], at[64]); + COMBA_STORE(C->dp[48]); + /* 49 */ + COMBA_FORWARD; + MULADD(at[0], at[113]); MULADD(at[1], at[112]); MULADD(at[2], at[111]); MULADD(at[3], at[110]); MULADD(at[4], at[109]); MULADD(at[5], at[108]); MULADD(at[6], at[107]); MULADD(at[7], at[106]); MULADD(at[8], at[105]); MULADD(at[9], at[104]); MULADD(at[10], at[103]); MULADD(at[11], at[102]); MULADD(at[12], at[101]); MULADD(at[13], at[100]); MULADD(at[14], at[99]); MULADD(at[15], at[98]); MULADD(at[16], at[97]); MULADD(at[17], at[96]); MULADD(at[18], at[95]); MULADD(at[19], at[94]); MULADD(at[20], at[93]); MULADD(at[21], at[92]); MULADD(at[22], at[91]); MULADD(at[23], at[90]); MULADD(at[24], at[89]); MULADD(at[25], at[88]); MULADD(at[26], at[87]); MULADD(at[27], at[86]); MULADD(at[28], at[85]); MULADD(at[29], at[84]); MULADD(at[30], at[83]); MULADD(at[31], at[82]); MULADD(at[32], at[81]); MULADD(at[33], at[80]); MULADD(at[34], at[79]); MULADD(at[35], at[78]); MULADD(at[36], at[77]); MULADD(at[37], at[76]); MULADD(at[38], at[75]); MULADD(at[39], at[74]); MULADD(at[40], at[73]); MULADD(at[41], at[72]); MULADD(at[42], at[71]); MULADD(at[43], at[70]); MULADD(at[44], at[69]); MULADD(at[45], at[68]); MULADD(at[46], at[67]); MULADD(at[47], at[66]); MULADD(at[48], at[65]); MULADD(at[49], at[64]); + COMBA_STORE(C->dp[49]); + /* 50 */ + COMBA_FORWARD; + MULADD(at[0], at[114]); MULADD(at[1], at[113]); MULADD(at[2], at[112]); MULADD(at[3], at[111]); MULADD(at[4], at[110]); MULADD(at[5], at[109]); MULADD(at[6], at[108]); MULADD(at[7], at[107]); MULADD(at[8], at[106]); MULADD(at[9], at[105]); MULADD(at[10], at[104]); MULADD(at[11], at[103]); MULADD(at[12], at[102]); MULADD(at[13], at[101]); MULADD(at[14], at[100]); MULADD(at[15], at[99]); MULADD(at[16], at[98]); MULADD(at[17], at[97]); MULADD(at[18], at[96]); MULADD(at[19], at[95]); MULADD(at[20], at[94]); MULADD(at[21], at[93]); MULADD(at[22], at[92]); MULADD(at[23], at[91]); MULADD(at[24], at[90]); MULADD(at[25], at[89]); MULADD(at[26], at[88]); MULADD(at[27], at[87]); MULADD(at[28], at[86]); MULADD(at[29], at[85]); MULADD(at[30], at[84]); MULADD(at[31], at[83]); MULADD(at[32], at[82]); MULADD(at[33], at[81]); MULADD(at[34], at[80]); MULADD(at[35], at[79]); MULADD(at[36], at[78]); MULADD(at[37], at[77]); MULADD(at[38], at[76]); MULADD(at[39], at[75]); MULADD(at[40], at[74]); MULADD(at[41], at[73]); MULADD(at[42], at[72]); MULADD(at[43], at[71]); MULADD(at[44], at[70]); MULADD(at[45], at[69]); MULADD(at[46], at[68]); MULADD(at[47], at[67]); MULADD(at[48], at[66]); MULADD(at[49], at[65]); MULADD(at[50], at[64]); + COMBA_STORE(C->dp[50]); + /* 51 */ + COMBA_FORWARD; + MULADD(at[0], at[115]); MULADD(at[1], at[114]); MULADD(at[2], at[113]); MULADD(at[3], at[112]); MULADD(at[4], at[111]); MULADD(at[5], at[110]); MULADD(at[6], at[109]); MULADD(at[7], at[108]); MULADD(at[8], at[107]); MULADD(at[9], at[106]); MULADD(at[10], at[105]); MULADD(at[11], at[104]); MULADD(at[12], at[103]); MULADD(at[13], at[102]); MULADD(at[14], at[101]); MULADD(at[15], at[100]); MULADD(at[16], at[99]); MULADD(at[17], at[98]); MULADD(at[18], at[97]); MULADD(at[19], at[96]); MULADD(at[20], at[95]); MULADD(at[21], at[94]); MULADD(at[22], at[93]); MULADD(at[23], at[92]); MULADD(at[24], at[91]); MULADD(at[25], at[90]); MULADD(at[26], at[89]); MULADD(at[27], at[88]); MULADD(at[28], at[87]); MULADD(at[29], at[86]); MULADD(at[30], at[85]); MULADD(at[31], at[84]); MULADD(at[32], at[83]); MULADD(at[33], at[82]); MULADD(at[34], at[81]); MULADD(at[35], at[80]); MULADD(at[36], at[79]); MULADD(at[37], at[78]); MULADD(at[38], at[77]); MULADD(at[39], at[76]); MULADD(at[40], at[75]); MULADD(at[41], at[74]); MULADD(at[42], at[73]); MULADD(at[43], at[72]); MULADD(at[44], at[71]); MULADD(at[45], at[70]); MULADD(at[46], at[69]); MULADD(at[47], at[68]); MULADD(at[48], at[67]); MULADD(at[49], at[66]); MULADD(at[50], at[65]); MULADD(at[51], at[64]); + COMBA_STORE(C->dp[51]); + /* 52 */ + COMBA_FORWARD; + MULADD(at[0], at[116]); MULADD(at[1], at[115]); MULADD(at[2], at[114]); MULADD(at[3], at[113]); MULADD(at[4], at[112]); MULADD(at[5], at[111]); MULADD(at[6], at[110]); MULADD(at[7], at[109]); MULADD(at[8], at[108]); MULADD(at[9], at[107]); MULADD(at[10], at[106]); MULADD(at[11], at[105]); MULADD(at[12], at[104]); MULADD(at[13], at[103]); MULADD(at[14], at[102]); MULADD(at[15], at[101]); MULADD(at[16], at[100]); MULADD(at[17], at[99]); MULADD(at[18], at[98]); MULADD(at[19], at[97]); MULADD(at[20], at[96]); MULADD(at[21], at[95]); MULADD(at[22], at[94]); MULADD(at[23], at[93]); MULADD(at[24], at[92]); MULADD(at[25], at[91]); MULADD(at[26], at[90]); MULADD(at[27], at[89]); MULADD(at[28], at[88]); MULADD(at[29], at[87]); MULADD(at[30], at[86]); MULADD(at[31], at[85]); MULADD(at[32], at[84]); MULADD(at[33], at[83]); MULADD(at[34], at[82]); MULADD(at[35], at[81]); MULADD(at[36], at[80]); MULADD(at[37], at[79]); MULADD(at[38], at[78]); MULADD(at[39], at[77]); MULADD(at[40], at[76]); MULADD(at[41], at[75]); MULADD(at[42], at[74]); MULADD(at[43], at[73]); MULADD(at[44], at[72]); MULADD(at[45], at[71]); MULADD(at[46], at[70]); MULADD(at[47], at[69]); MULADD(at[48], at[68]); MULADD(at[49], at[67]); MULADD(at[50], at[66]); MULADD(at[51], at[65]); MULADD(at[52], at[64]); + COMBA_STORE(C->dp[52]); + /* 53 */ + COMBA_FORWARD; + MULADD(at[0], at[117]); MULADD(at[1], at[116]); MULADD(at[2], at[115]); MULADD(at[3], at[114]); MULADD(at[4], at[113]); MULADD(at[5], at[112]); MULADD(at[6], at[111]); MULADD(at[7], at[110]); MULADD(at[8], at[109]); MULADD(at[9], at[108]); MULADD(at[10], at[107]); MULADD(at[11], at[106]); MULADD(at[12], at[105]); MULADD(at[13], at[104]); MULADD(at[14], at[103]); MULADD(at[15], at[102]); MULADD(at[16], at[101]); MULADD(at[17], at[100]); MULADD(at[18], at[99]); MULADD(at[19], at[98]); MULADD(at[20], at[97]); MULADD(at[21], at[96]); MULADD(at[22], at[95]); MULADD(at[23], at[94]); MULADD(at[24], at[93]); MULADD(at[25], at[92]); MULADD(at[26], at[91]); MULADD(at[27], at[90]); MULADD(at[28], at[89]); MULADD(at[29], at[88]); MULADD(at[30], at[87]); MULADD(at[31], at[86]); MULADD(at[32], at[85]); MULADD(at[33], at[84]); MULADD(at[34], at[83]); MULADD(at[35], at[82]); MULADD(at[36], at[81]); MULADD(at[37], at[80]); MULADD(at[38], at[79]); MULADD(at[39], at[78]); MULADD(at[40], at[77]); MULADD(at[41], at[76]); MULADD(at[42], at[75]); MULADD(at[43], at[74]); MULADD(at[44], at[73]); MULADD(at[45], at[72]); MULADD(at[46], at[71]); MULADD(at[47], at[70]); MULADD(at[48], at[69]); MULADD(at[49], at[68]); MULADD(at[50], at[67]); MULADD(at[51], at[66]); MULADD(at[52], at[65]); MULADD(at[53], at[64]); + COMBA_STORE(C->dp[53]); + /* 54 */ + COMBA_FORWARD; + MULADD(at[0], at[118]); MULADD(at[1], at[117]); MULADD(at[2], at[116]); MULADD(at[3], at[115]); MULADD(at[4], at[114]); MULADD(at[5], at[113]); MULADD(at[6], at[112]); MULADD(at[7], at[111]); MULADD(at[8], at[110]); MULADD(at[9], at[109]); MULADD(at[10], at[108]); MULADD(at[11], at[107]); MULADD(at[12], at[106]); MULADD(at[13], at[105]); MULADD(at[14], at[104]); MULADD(at[15], at[103]); MULADD(at[16], at[102]); MULADD(at[17], at[101]); MULADD(at[18], at[100]); MULADD(at[19], at[99]); MULADD(at[20], at[98]); MULADD(at[21], at[97]); MULADD(at[22], at[96]); MULADD(at[23], at[95]); MULADD(at[24], at[94]); MULADD(at[25], at[93]); MULADD(at[26], at[92]); MULADD(at[27], at[91]); MULADD(at[28], at[90]); MULADD(at[29], at[89]); MULADD(at[30], at[88]); MULADD(at[31], at[87]); MULADD(at[32], at[86]); MULADD(at[33], at[85]); MULADD(at[34], at[84]); MULADD(at[35], at[83]); MULADD(at[36], at[82]); MULADD(at[37], at[81]); MULADD(at[38], at[80]); MULADD(at[39], at[79]); MULADD(at[40], at[78]); MULADD(at[41], at[77]); MULADD(at[42], at[76]); MULADD(at[43], at[75]); MULADD(at[44], at[74]); MULADD(at[45], at[73]); MULADD(at[46], at[72]); MULADD(at[47], at[71]); MULADD(at[48], at[70]); MULADD(at[49], at[69]); MULADD(at[50], at[68]); MULADD(at[51], at[67]); MULADD(at[52], at[66]); MULADD(at[53], at[65]); MULADD(at[54], at[64]); + COMBA_STORE(C->dp[54]); + /* 55 */ + COMBA_FORWARD; + MULADD(at[0], at[119]); MULADD(at[1], at[118]); MULADD(at[2], at[117]); MULADD(at[3], at[116]); MULADD(at[4], at[115]); MULADD(at[5], at[114]); MULADD(at[6], at[113]); MULADD(at[7], at[112]); MULADD(at[8], at[111]); MULADD(at[9], at[110]); MULADD(at[10], at[109]); MULADD(at[11], at[108]); MULADD(at[12], at[107]); MULADD(at[13], at[106]); MULADD(at[14], at[105]); MULADD(at[15], at[104]); MULADD(at[16], at[103]); MULADD(at[17], at[102]); MULADD(at[18], at[101]); MULADD(at[19], at[100]); MULADD(at[20], at[99]); MULADD(at[21], at[98]); MULADD(at[22], at[97]); MULADD(at[23], at[96]); MULADD(at[24], at[95]); MULADD(at[25], at[94]); MULADD(at[26], at[93]); MULADD(at[27], at[92]); MULADD(at[28], at[91]); MULADD(at[29], at[90]); MULADD(at[30], at[89]); MULADD(at[31], at[88]); MULADD(at[32], at[87]); MULADD(at[33], at[86]); MULADD(at[34], at[85]); MULADD(at[35], at[84]); MULADD(at[36], at[83]); MULADD(at[37], at[82]); MULADD(at[38], at[81]); MULADD(at[39], at[80]); MULADD(at[40], at[79]); MULADD(at[41], at[78]); MULADD(at[42], at[77]); MULADD(at[43], at[76]); MULADD(at[44], at[75]); MULADD(at[45], at[74]); MULADD(at[46], at[73]); MULADD(at[47], at[72]); MULADD(at[48], at[71]); MULADD(at[49], at[70]); MULADD(at[50], at[69]); MULADD(at[51], at[68]); MULADD(at[52], at[67]); MULADD(at[53], at[66]); MULADD(at[54], at[65]); MULADD(at[55], at[64]); + COMBA_STORE(C->dp[55]); + /* 56 */ + COMBA_FORWARD; + MULADD(at[0], at[120]); MULADD(at[1], at[119]); MULADD(at[2], at[118]); MULADD(at[3], at[117]); MULADD(at[4], at[116]); MULADD(at[5], at[115]); MULADD(at[6], at[114]); MULADD(at[7], at[113]); MULADD(at[8], at[112]); MULADD(at[9], at[111]); MULADD(at[10], at[110]); MULADD(at[11], at[109]); MULADD(at[12], at[108]); MULADD(at[13], at[107]); MULADD(at[14], at[106]); MULADD(at[15], at[105]); MULADD(at[16], at[104]); MULADD(at[17], at[103]); MULADD(at[18], at[102]); MULADD(at[19], at[101]); MULADD(at[20], at[100]); MULADD(at[21], at[99]); MULADD(at[22], at[98]); MULADD(at[23], at[97]); MULADD(at[24], at[96]); MULADD(at[25], at[95]); MULADD(at[26], at[94]); MULADD(at[27], at[93]); MULADD(at[28], at[92]); MULADD(at[29], at[91]); MULADD(at[30], at[90]); MULADD(at[31], at[89]); MULADD(at[32], at[88]); MULADD(at[33], at[87]); MULADD(at[34], at[86]); MULADD(at[35], at[85]); MULADD(at[36], at[84]); MULADD(at[37], at[83]); MULADD(at[38], at[82]); MULADD(at[39], at[81]); MULADD(at[40], at[80]); MULADD(at[41], at[79]); MULADD(at[42], at[78]); MULADD(at[43], at[77]); MULADD(at[44], at[76]); MULADD(at[45], at[75]); MULADD(at[46], at[74]); MULADD(at[47], at[73]); MULADD(at[48], at[72]); MULADD(at[49], at[71]); MULADD(at[50], at[70]); MULADD(at[51], at[69]); MULADD(at[52], at[68]); MULADD(at[53], at[67]); MULADD(at[54], at[66]); MULADD(at[55], at[65]); MULADD(at[56], at[64]); + COMBA_STORE(C->dp[56]); + /* 57 */ + COMBA_FORWARD; + MULADD(at[0], at[121]); MULADD(at[1], at[120]); MULADD(at[2], at[119]); MULADD(at[3], at[118]); MULADD(at[4], at[117]); MULADD(at[5], at[116]); MULADD(at[6], at[115]); MULADD(at[7], at[114]); MULADD(at[8], at[113]); MULADD(at[9], at[112]); MULADD(at[10], at[111]); MULADD(at[11], at[110]); MULADD(at[12], at[109]); MULADD(at[13], at[108]); MULADD(at[14], at[107]); MULADD(at[15], at[106]); MULADD(at[16], at[105]); MULADD(at[17], at[104]); MULADD(at[18], at[103]); MULADD(at[19], at[102]); MULADD(at[20], at[101]); MULADD(at[21], at[100]); MULADD(at[22], at[99]); MULADD(at[23], at[98]); MULADD(at[24], at[97]); MULADD(at[25], at[96]); MULADD(at[26], at[95]); MULADD(at[27], at[94]); MULADD(at[28], at[93]); MULADD(at[29], at[92]); MULADD(at[30], at[91]); MULADD(at[31], at[90]); MULADD(at[32], at[89]); MULADD(at[33], at[88]); MULADD(at[34], at[87]); MULADD(at[35], at[86]); MULADD(at[36], at[85]); MULADD(at[37], at[84]); MULADD(at[38], at[83]); MULADD(at[39], at[82]); MULADD(at[40], at[81]); MULADD(at[41], at[80]); MULADD(at[42], at[79]); MULADD(at[43], at[78]); MULADD(at[44], at[77]); MULADD(at[45], at[76]); MULADD(at[46], at[75]); MULADD(at[47], at[74]); MULADD(at[48], at[73]); MULADD(at[49], at[72]); MULADD(at[50], at[71]); MULADD(at[51], at[70]); MULADD(at[52], at[69]); MULADD(at[53], at[68]); MULADD(at[54], at[67]); MULADD(at[55], at[66]); MULADD(at[56], at[65]); MULADD(at[57], at[64]); + COMBA_STORE(C->dp[57]); + /* 58 */ + COMBA_FORWARD; + MULADD(at[0], at[122]); MULADD(at[1], at[121]); MULADD(at[2], at[120]); MULADD(at[3], at[119]); MULADD(at[4], at[118]); MULADD(at[5], at[117]); MULADD(at[6], at[116]); MULADD(at[7], at[115]); MULADD(at[8], at[114]); MULADD(at[9], at[113]); MULADD(at[10], at[112]); MULADD(at[11], at[111]); MULADD(at[12], at[110]); MULADD(at[13], at[109]); MULADD(at[14], at[108]); MULADD(at[15], at[107]); MULADD(at[16], at[106]); MULADD(at[17], at[105]); MULADD(at[18], at[104]); MULADD(at[19], at[103]); MULADD(at[20], at[102]); MULADD(at[21], at[101]); MULADD(at[22], at[100]); MULADD(at[23], at[99]); MULADD(at[24], at[98]); MULADD(at[25], at[97]); MULADD(at[26], at[96]); MULADD(at[27], at[95]); MULADD(at[28], at[94]); MULADD(at[29], at[93]); MULADD(at[30], at[92]); MULADD(at[31], at[91]); MULADD(at[32], at[90]); MULADD(at[33], at[89]); MULADD(at[34], at[88]); MULADD(at[35], at[87]); MULADD(at[36], at[86]); MULADD(at[37], at[85]); MULADD(at[38], at[84]); MULADD(at[39], at[83]); MULADD(at[40], at[82]); MULADD(at[41], at[81]); MULADD(at[42], at[80]); MULADD(at[43], at[79]); MULADD(at[44], at[78]); MULADD(at[45], at[77]); MULADD(at[46], at[76]); MULADD(at[47], at[75]); MULADD(at[48], at[74]); MULADD(at[49], at[73]); MULADD(at[50], at[72]); MULADD(at[51], at[71]); MULADD(at[52], at[70]); MULADD(at[53], at[69]); MULADD(at[54], at[68]); MULADD(at[55], at[67]); MULADD(at[56], at[66]); MULADD(at[57], at[65]); MULADD(at[58], at[64]); + COMBA_STORE(C->dp[58]); + /* 59 */ + COMBA_FORWARD; + MULADD(at[0], at[123]); MULADD(at[1], at[122]); MULADD(at[2], at[121]); MULADD(at[3], at[120]); MULADD(at[4], at[119]); MULADD(at[5], at[118]); MULADD(at[6], at[117]); MULADD(at[7], at[116]); MULADD(at[8], at[115]); MULADD(at[9], at[114]); MULADD(at[10], at[113]); MULADD(at[11], at[112]); MULADD(at[12], at[111]); MULADD(at[13], at[110]); MULADD(at[14], at[109]); MULADD(at[15], at[108]); MULADD(at[16], at[107]); MULADD(at[17], at[106]); MULADD(at[18], at[105]); MULADD(at[19], at[104]); MULADD(at[20], at[103]); MULADD(at[21], at[102]); MULADD(at[22], at[101]); MULADD(at[23], at[100]); MULADD(at[24], at[99]); MULADD(at[25], at[98]); MULADD(at[26], at[97]); MULADD(at[27], at[96]); MULADD(at[28], at[95]); MULADD(at[29], at[94]); MULADD(at[30], at[93]); MULADD(at[31], at[92]); MULADD(at[32], at[91]); MULADD(at[33], at[90]); MULADD(at[34], at[89]); MULADD(at[35], at[88]); MULADD(at[36], at[87]); MULADD(at[37], at[86]); MULADD(at[38], at[85]); MULADD(at[39], at[84]); MULADD(at[40], at[83]); MULADD(at[41], at[82]); MULADD(at[42], at[81]); MULADD(at[43], at[80]); MULADD(at[44], at[79]); MULADD(at[45], at[78]); MULADD(at[46], at[77]); MULADD(at[47], at[76]); MULADD(at[48], at[75]); MULADD(at[49], at[74]); MULADD(at[50], at[73]); MULADD(at[51], at[72]); MULADD(at[52], at[71]); MULADD(at[53], at[70]); MULADD(at[54], at[69]); MULADD(at[55], at[68]); MULADD(at[56], at[67]); MULADD(at[57], at[66]); MULADD(at[58], at[65]); MULADD(at[59], at[64]); + COMBA_STORE(C->dp[59]); + /* 60 */ + COMBA_FORWARD; + MULADD(at[0], at[124]); MULADD(at[1], at[123]); MULADD(at[2], at[122]); MULADD(at[3], at[121]); MULADD(at[4], at[120]); MULADD(at[5], at[119]); MULADD(at[6], at[118]); MULADD(at[7], at[117]); MULADD(at[8], at[116]); MULADD(at[9], at[115]); MULADD(at[10], at[114]); MULADD(at[11], at[113]); MULADD(at[12], at[112]); MULADD(at[13], at[111]); MULADD(at[14], at[110]); MULADD(at[15], at[109]); MULADD(at[16], at[108]); MULADD(at[17], at[107]); MULADD(at[18], at[106]); MULADD(at[19], at[105]); MULADD(at[20], at[104]); MULADD(at[21], at[103]); MULADD(at[22], at[102]); MULADD(at[23], at[101]); MULADD(at[24], at[100]); MULADD(at[25], at[99]); MULADD(at[26], at[98]); MULADD(at[27], at[97]); MULADD(at[28], at[96]); MULADD(at[29], at[95]); MULADD(at[30], at[94]); MULADD(at[31], at[93]); MULADD(at[32], at[92]); MULADD(at[33], at[91]); MULADD(at[34], at[90]); MULADD(at[35], at[89]); MULADD(at[36], at[88]); MULADD(at[37], at[87]); MULADD(at[38], at[86]); MULADD(at[39], at[85]); MULADD(at[40], at[84]); MULADD(at[41], at[83]); MULADD(at[42], at[82]); MULADD(at[43], at[81]); MULADD(at[44], at[80]); MULADD(at[45], at[79]); MULADD(at[46], at[78]); MULADD(at[47], at[77]); MULADD(at[48], at[76]); MULADD(at[49], at[75]); MULADD(at[50], at[74]); MULADD(at[51], at[73]); MULADD(at[52], at[72]); MULADD(at[53], at[71]); MULADD(at[54], at[70]); MULADD(at[55], at[69]); MULADD(at[56], at[68]); MULADD(at[57], at[67]); MULADD(at[58], at[66]); MULADD(at[59], at[65]); MULADD(at[60], at[64]); + COMBA_STORE(C->dp[60]); + /* 61 */ + COMBA_FORWARD; + MULADD(at[0], at[125]); MULADD(at[1], at[124]); MULADD(at[2], at[123]); MULADD(at[3], at[122]); MULADD(at[4], at[121]); MULADD(at[5], at[120]); MULADD(at[6], at[119]); MULADD(at[7], at[118]); MULADD(at[8], at[117]); MULADD(at[9], at[116]); MULADD(at[10], at[115]); MULADD(at[11], at[114]); MULADD(at[12], at[113]); MULADD(at[13], at[112]); MULADD(at[14], at[111]); MULADD(at[15], at[110]); MULADD(at[16], at[109]); MULADD(at[17], at[108]); MULADD(at[18], at[107]); MULADD(at[19], at[106]); MULADD(at[20], at[105]); MULADD(at[21], at[104]); MULADD(at[22], at[103]); MULADD(at[23], at[102]); MULADD(at[24], at[101]); MULADD(at[25], at[100]); MULADD(at[26], at[99]); MULADD(at[27], at[98]); MULADD(at[28], at[97]); MULADD(at[29], at[96]); MULADD(at[30], at[95]); MULADD(at[31], at[94]); MULADD(at[32], at[93]); MULADD(at[33], at[92]); MULADD(at[34], at[91]); MULADD(at[35], at[90]); MULADD(at[36], at[89]); MULADD(at[37], at[88]); MULADD(at[38], at[87]); MULADD(at[39], at[86]); MULADD(at[40], at[85]); MULADD(at[41], at[84]); MULADD(at[42], at[83]); MULADD(at[43], at[82]); MULADD(at[44], at[81]); MULADD(at[45], at[80]); MULADD(at[46], at[79]); MULADD(at[47], at[78]); MULADD(at[48], at[77]); MULADD(at[49], at[76]); MULADD(at[50], at[75]); MULADD(at[51], at[74]); MULADD(at[52], at[73]); MULADD(at[53], at[72]); MULADD(at[54], at[71]); MULADD(at[55], at[70]); MULADD(at[56], at[69]); MULADD(at[57], at[68]); MULADD(at[58], at[67]); MULADD(at[59], at[66]); MULADD(at[60], at[65]); MULADD(at[61], at[64]); + COMBA_STORE(C->dp[61]); + /* 62 */ + COMBA_FORWARD; + MULADD(at[0], at[126]); MULADD(at[1], at[125]); MULADD(at[2], at[124]); MULADD(at[3], at[123]); MULADD(at[4], at[122]); MULADD(at[5], at[121]); MULADD(at[6], at[120]); MULADD(at[7], at[119]); MULADD(at[8], at[118]); MULADD(at[9], at[117]); MULADD(at[10], at[116]); MULADD(at[11], at[115]); MULADD(at[12], at[114]); MULADD(at[13], at[113]); MULADD(at[14], at[112]); MULADD(at[15], at[111]); MULADD(at[16], at[110]); MULADD(at[17], at[109]); MULADD(at[18], at[108]); MULADD(at[19], at[107]); MULADD(at[20], at[106]); MULADD(at[21], at[105]); MULADD(at[22], at[104]); MULADD(at[23], at[103]); MULADD(at[24], at[102]); MULADD(at[25], at[101]); MULADD(at[26], at[100]); MULADD(at[27], at[99]); MULADD(at[28], at[98]); MULADD(at[29], at[97]); MULADD(at[30], at[96]); MULADD(at[31], at[95]); MULADD(at[32], at[94]); MULADD(at[33], at[93]); MULADD(at[34], at[92]); MULADD(at[35], at[91]); MULADD(at[36], at[90]); MULADD(at[37], at[89]); MULADD(at[38], at[88]); MULADD(at[39], at[87]); MULADD(at[40], at[86]); MULADD(at[41], at[85]); MULADD(at[42], at[84]); MULADD(at[43], at[83]); MULADD(at[44], at[82]); MULADD(at[45], at[81]); MULADD(at[46], at[80]); MULADD(at[47], at[79]); MULADD(at[48], at[78]); MULADD(at[49], at[77]); MULADD(at[50], at[76]); MULADD(at[51], at[75]); MULADD(at[52], at[74]); MULADD(at[53], at[73]); MULADD(at[54], at[72]); MULADD(at[55], at[71]); MULADD(at[56], at[70]); MULADD(at[57], at[69]); MULADD(at[58], at[68]); MULADD(at[59], at[67]); MULADD(at[60], at[66]); MULADD(at[61], at[65]); MULADD(at[62], at[64]); + COMBA_STORE(C->dp[62]); + /* 63 */ + COMBA_FORWARD; + MULADD(at[0], at[127]); MULADD(at[1], at[126]); MULADD(at[2], at[125]); MULADD(at[3], at[124]); MULADD(at[4], at[123]); MULADD(at[5], at[122]); MULADD(at[6], at[121]); MULADD(at[7], at[120]); MULADD(at[8], at[119]); MULADD(at[9], at[118]); MULADD(at[10], at[117]); MULADD(at[11], at[116]); MULADD(at[12], at[115]); MULADD(at[13], at[114]); MULADD(at[14], at[113]); MULADD(at[15], at[112]); MULADD(at[16], at[111]); MULADD(at[17], at[110]); MULADD(at[18], at[109]); MULADD(at[19], at[108]); MULADD(at[20], at[107]); MULADD(at[21], at[106]); MULADD(at[22], at[105]); MULADD(at[23], at[104]); MULADD(at[24], at[103]); MULADD(at[25], at[102]); MULADD(at[26], at[101]); MULADD(at[27], at[100]); MULADD(at[28], at[99]); MULADD(at[29], at[98]); MULADD(at[30], at[97]); MULADD(at[31], at[96]); MULADD(at[32], at[95]); MULADD(at[33], at[94]); MULADD(at[34], at[93]); MULADD(at[35], at[92]); MULADD(at[36], at[91]); MULADD(at[37], at[90]); MULADD(at[38], at[89]); MULADD(at[39], at[88]); MULADD(at[40], at[87]); MULADD(at[41], at[86]); MULADD(at[42], at[85]); MULADD(at[43], at[84]); MULADD(at[44], at[83]); MULADD(at[45], at[82]); MULADD(at[46], at[81]); MULADD(at[47], at[80]); MULADD(at[48], at[79]); MULADD(at[49], at[78]); MULADD(at[50], at[77]); MULADD(at[51], at[76]); MULADD(at[52], at[75]); MULADD(at[53], at[74]); MULADD(at[54], at[73]); MULADD(at[55], at[72]); MULADD(at[56], at[71]); MULADD(at[57], at[70]); MULADD(at[58], at[69]); MULADD(at[59], at[68]); MULADD(at[60], at[67]); MULADD(at[61], at[66]); MULADD(at[62], at[65]); MULADD(at[63], at[64]); + COMBA_STORE(C->dp[63]); + /* 64 */ + COMBA_FORWARD; + MULADD(at[1], at[127]); MULADD(at[2], at[126]); MULADD(at[3], at[125]); MULADD(at[4], at[124]); MULADD(at[5], at[123]); MULADD(at[6], at[122]); MULADD(at[7], at[121]); MULADD(at[8], at[120]); MULADD(at[9], at[119]); MULADD(at[10], at[118]); MULADD(at[11], at[117]); MULADD(at[12], at[116]); MULADD(at[13], at[115]); MULADD(at[14], at[114]); MULADD(at[15], at[113]); MULADD(at[16], at[112]); MULADD(at[17], at[111]); MULADD(at[18], at[110]); MULADD(at[19], at[109]); MULADD(at[20], at[108]); MULADD(at[21], at[107]); MULADD(at[22], at[106]); MULADD(at[23], at[105]); MULADD(at[24], at[104]); MULADD(at[25], at[103]); MULADD(at[26], at[102]); MULADD(at[27], at[101]); MULADD(at[28], at[100]); MULADD(at[29], at[99]); MULADD(at[30], at[98]); MULADD(at[31], at[97]); MULADD(at[32], at[96]); MULADD(at[33], at[95]); MULADD(at[34], at[94]); MULADD(at[35], at[93]); MULADD(at[36], at[92]); MULADD(at[37], at[91]); MULADD(at[38], at[90]); MULADD(at[39], at[89]); MULADD(at[40], at[88]); MULADD(at[41], at[87]); MULADD(at[42], at[86]); MULADD(at[43], at[85]); MULADD(at[44], at[84]); MULADD(at[45], at[83]); MULADD(at[46], at[82]); MULADD(at[47], at[81]); MULADD(at[48], at[80]); MULADD(at[49], at[79]); MULADD(at[50], at[78]); MULADD(at[51], at[77]); MULADD(at[52], at[76]); MULADD(at[53], at[75]); MULADD(at[54], at[74]); MULADD(at[55], at[73]); MULADD(at[56], at[72]); MULADD(at[57], at[71]); MULADD(at[58], at[70]); MULADD(at[59], at[69]); MULADD(at[60], at[68]); MULADD(at[61], at[67]); MULADD(at[62], at[66]); MULADD(at[63], at[65]); + COMBA_STORE(C->dp[64]); + /* 65 */ + COMBA_FORWARD; + MULADD(at[2], at[127]); MULADD(at[3], at[126]); MULADD(at[4], at[125]); MULADD(at[5], at[124]); MULADD(at[6], at[123]); MULADD(at[7], at[122]); MULADD(at[8], at[121]); MULADD(at[9], at[120]); MULADD(at[10], at[119]); MULADD(at[11], at[118]); MULADD(at[12], at[117]); MULADD(at[13], at[116]); MULADD(at[14], at[115]); MULADD(at[15], at[114]); MULADD(at[16], at[113]); MULADD(at[17], at[112]); MULADD(at[18], at[111]); MULADD(at[19], at[110]); MULADD(at[20], at[109]); MULADD(at[21], at[108]); MULADD(at[22], at[107]); MULADD(at[23], at[106]); MULADD(at[24], at[105]); MULADD(at[25], at[104]); MULADD(at[26], at[103]); MULADD(at[27], at[102]); MULADD(at[28], at[101]); MULADD(at[29], at[100]); MULADD(at[30], at[99]); MULADD(at[31], at[98]); MULADD(at[32], at[97]); MULADD(at[33], at[96]); MULADD(at[34], at[95]); MULADD(at[35], at[94]); MULADD(at[36], at[93]); MULADD(at[37], at[92]); MULADD(at[38], at[91]); MULADD(at[39], at[90]); MULADD(at[40], at[89]); MULADD(at[41], at[88]); MULADD(at[42], at[87]); MULADD(at[43], at[86]); MULADD(at[44], at[85]); MULADD(at[45], at[84]); MULADD(at[46], at[83]); MULADD(at[47], at[82]); MULADD(at[48], at[81]); MULADD(at[49], at[80]); MULADD(at[50], at[79]); MULADD(at[51], at[78]); MULADD(at[52], at[77]); MULADD(at[53], at[76]); MULADD(at[54], at[75]); MULADD(at[55], at[74]); MULADD(at[56], at[73]); MULADD(at[57], at[72]); MULADD(at[58], at[71]); MULADD(at[59], at[70]); MULADD(at[60], at[69]); MULADD(at[61], at[68]); MULADD(at[62], at[67]); MULADD(at[63], at[66]); + COMBA_STORE(C->dp[65]); + /* 66 */ + COMBA_FORWARD; + MULADD(at[3], at[127]); MULADD(at[4], at[126]); MULADD(at[5], at[125]); MULADD(at[6], at[124]); MULADD(at[7], at[123]); MULADD(at[8], at[122]); MULADD(at[9], at[121]); MULADD(at[10], at[120]); MULADD(at[11], at[119]); MULADD(at[12], at[118]); MULADD(at[13], at[117]); MULADD(at[14], at[116]); MULADD(at[15], at[115]); MULADD(at[16], at[114]); MULADD(at[17], at[113]); MULADD(at[18], at[112]); MULADD(at[19], at[111]); MULADD(at[20], at[110]); MULADD(at[21], at[109]); MULADD(at[22], at[108]); MULADD(at[23], at[107]); MULADD(at[24], at[106]); MULADD(at[25], at[105]); MULADD(at[26], at[104]); MULADD(at[27], at[103]); MULADD(at[28], at[102]); MULADD(at[29], at[101]); MULADD(at[30], at[100]); MULADD(at[31], at[99]); MULADD(at[32], at[98]); MULADD(at[33], at[97]); MULADD(at[34], at[96]); MULADD(at[35], at[95]); MULADD(at[36], at[94]); MULADD(at[37], at[93]); MULADD(at[38], at[92]); MULADD(at[39], at[91]); MULADD(at[40], at[90]); MULADD(at[41], at[89]); MULADD(at[42], at[88]); MULADD(at[43], at[87]); MULADD(at[44], at[86]); MULADD(at[45], at[85]); MULADD(at[46], at[84]); MULADD(at[47], at[83]); MULADD(at[48], at[82]); MULADD(at[49], at[81]); MULADD(at[50], at[80]); MULADD(at[51], at[79]); MULADD(at[52], at[78]); MULADD(at[53], at[77]); MULADD(at[54], at[76]); MULADD(at[55], at[75]); MULADD(at[56], at[74]); MULADD(at[57], at[73]); MULADD(at[58], at[72]); MULADD(at[59], at[71]); MULADD(at[60], at[70]); MULADD(at[61], at[69]); MULADD(at[62], at[68]); MULADD(at[63], at[67]); + COMBA_STORE(C->dp[66]); + /* 67 */ + COMBA_FORWARD; + MULADD(at[4], at[127]); MULADD(at[5], at[126]); MULADD(at[6], at[125]); MULADD(at[7], at[124]); MULADD(at[8], at[123]); MULADD(at[9], at[122]); MULADD(at[10], at[121]); MULADD(at[11], at[120]); MULADD(at[12], at[119]); MULADD(at[13], at[118]); MULADD(at[14], at[117]); MULADD(at[15], at[116]); MULADD(at[16], at[115]); MULADD(at[17], at[114]); MULADD(at[18], at[113]); MULADD(at[19], at[112]); MULADD(at[20], at[111]); MULADD(at[21], at[110]); MULADD(at[22], at[109]); MULADD(at[23], at[108]); MULADD(at[24], at[107]); MULADD(at[25], at[106]); MULADD(at[26], at[105]); MULADD(at[27], at[104]); MULADD(at[28], at[103]); MULADD(at[29], at[102]); MULADD(at[30], at[101]); MULADD(at[31], at[100]); MULADD(at[32], at[99]); MULADD(at[33], at[98]); MULADD(at[34], at[97]); MULADD(at[35], at[96]); MULADD(at[36], at[95]); MULADD(at[37], at[94]); MULADD(at[38], at[93]); MULADD(at[39], at[92]); MULADD(at[40], at[91]); MULADD(at[41], at[90]); MULADD(at[42], at[89]); MULADD(at[43], at[88]); MULADD(at[44], at[87]); MULADD(at[45], at[86]); MULADD(at[46], at[85]); MULADD(at[47], at[84]); MULADD(at[48], at[83]); MULADD(at[49], at[82]); MULADD(at[50], at[81]); MULADD(at[51], at[80]); MULADD(at[52], at[79]); MULADD(at[53], at[78]); MULADD(at[54], at[77]); MULADD(at[55], at[76]); MULADD(at[56], at[75]); MULADD(at[57], at[74]); MULADD(at[58], at[73]); MULADD(at[59], at[72]); MULADD(at[60], at[71]); MULADD(at[61], at[70]); MULADD(at[62], at[69]); MULADD(at[63], at[68]); + COMBA_STORE(C->dp[67]); + /* 68 */ + COMBA_FORWARD; + MULADD(at[5], at[127]); MULADD(at[6], at[126]); MULADD(at[7], at[125]); MULADD(at[8], at[124]); MULADD(at[9], at[123]); MULADD(at[10], at[122]); MULADD(at[11], at[121]); MULADD(at[12], at[120]); MULADD(at[13], at[119]); MULADD(at[14], at[118]); MULADD(at[15], at[117]); MULADD(at[16], at[116]); MULADD(at[17], at[115]); MULADD(at[18], at[114]); MULADD(at[19], at[113]); MULADD(at[20], at[112]); MULADD(at[21], at[111]); MULADD(at[22], at[110]); MULADD(at[23], at[109]); MULADD(at[24], at[108]); MULADD(at[25], at[107]); MULADD(at[26], at[106]); MULADD(at[27], at[105]); MULADD(at[28], at[104]); MULADD(at[29], at[103]); MULADD(at[30], at[102]); MULADD(at[31], at[101]); MULADD(at[32], at[100]); MULADD(at[33], at[99]); MULADD(at[34], at[98]); MULADD(at[35], at[97]); MULADD(at[36], at[96]); MULADD(at[37], at[95]); MULADD(at[38], at[94]); MULADD(at[39], at[93]); MULADD(at[40], at[92]); MULADD(at[41], at[91]); MULADD(at[42], at[90]); MULADD(at[43], at[89]); MULADD(at[44], at[88]); MULADD(at[45], at[87]); MULADD(at[46], at[86]); MULADD(at[47], at[85]); MULADD(at[48], at[84]); MULADD(at[49], at[83]); MULADD(at[50], at[82]); MULADD(at[51], at[81]); MULADD(at[52], at[80]); MULADD(at[53], at[79]); MULADD(at[54], at[78]); MULADD(at[55], at[77]); MULADD(at[56], at[76]); MULADD(at[57], at[75]); MULADD(at[58], at[74]); MULADD(at[59], at[73]); MULADD(at[60], at[72]); MULADD(at[61], at[71]); MULADD(at[62], at[70]); MULADD(at[63], at[69]); + COMBA_STORE(C->dp[68]); + /* 69 */ + COMBA_FORWARD; + MULADD(at[6], at[127]); MULADD(at[7], at[126]); MULADD(at[8], at[125]); MULADD(at[9], at[124]); MULADD(at[10], at[123]); MULADD(at[11], at[122]); MULADD(at[12], at[121]); MULADD(at[13], at[120]); MULADD(at[14], at[119]); MULADD(at[15], at[118]); MULADD(at[16], at[117]); MULADD(at[17], at[116]); MULADD(at[18], at[115]); MULADD(at[19], at[114]); MULADD(at[20], at[113]); MULADD(at[21], at[112]); MULADD(at[22], at[111]); MULADD(at[23], at[110]); MULADD(at[24], at[109]); MULADD(at[25], at[108]); MULADD(at[26], at[107]); MULADD(at[27], at[106]); MULADD(at[28], at[105]); MULADD(at[29], at[104]); MULADD(at[30], at[103]); MULADD(at[31], at[102]); MULADD(at[32], at[101]); MULADD(at[33], at[100]); MULADD(at[34], at[99]); MULADD(at[35], at[98]); MULADD(at[36], at[97]); MULADD(at[37], at[96]); MULADD(at[38], at[95]); MULADD(at[39], at[94]); MULADD(at[40], at[93]); MULADD(at[41], at[92]); MULADD(at[42], at[91]); MULADD(at[43], at[90]); MULADD(at[44], at[89]); MULADD(at[45], at[88]); MULADD(at[46], at[87]); MULADD(at[47], at[86]); MULADD(at[48], at[85]); MULADD(at[49], at[84]); MULADD(at[50], at[83]); MULADD(at[51], at[82]); MULADD(at[52], at[81]); MULADD(at[53], at[80]); MULADD(at[54], at[79]); MULADD(at[55], at[78]); MULADD(at[56], at[77]); MULADD(at[57], at[76]); MULADD(at[58], at[75]); MULADD(at[59], at[74]); MULADD(at[60], at[73]); MULADD(at[61], at[72]); MULADD(at[62], at[71]); MULADD(at[63], at[70]); + COMBA_STORE(C->dp[69]); + /* 70 */ + COMBA_FORWARD; + MULADD(at[7], at[127]); MULADD(at[8], at[126]); MULADD(at[9], at[125]); MULADD(at[10], at[124]); MULADD(at[11], at[123]); MULADD(at[12], at[122]); MULADD(at[13], at[121]); MULADD(at[14], at[120]); MULADD(at[15], at[119]); MULADD(at[16], at[118]); MULADD(at[17], at[117]); MULADD(at[18], at[116]); MULADD(at[19], at[115]); MULADD(at[20], at[114]); MULADD(at[21], at[113]); MULADD(at[22], at[112]); MULADD(at[23], at[111]); MULADD(at[24], at[110]); MULADD(at[25], at[109]); MULADD(at[26], at[108]); MULADD(at[27], at[107]); MULADD(at[28], at[106]); MULADD(at[29], at[105]); MULADD(at[30], at[104]); MULADD(at[31], at[103]); MULADD(at[32], at[102]); MULADD(at[33], at[101]); MULADD(at[34], at[100]); MULADD(at[35], at[99]); MULADD(at[36], at[98]); MULADD(at[37], at[97]); MULADD(at[38], at[96]); MULADD(at[39], at[95]); MULADD(at[40], at[94]); MULADD(at[41], at[93]); MULADD(at[42], at[92]); MULADD(at[43], at[91]); MULADD(at[44], at[90]); MULADD(at[45], at[89]); MULADD(at[46], at[88]); MULADD(at[47], at[87]); MULADD(at[48], at[86]); MULADD(at[49], at[85]); MULADD(at[50], at[84]); MULADD(at[51], at[83]); MULADD(at[52], at[82]); MULADD(at[53], at[81]); MULADD(at[54], at[80]); MULADD(at[55], at[79]); MULADD(at[56], at[78]); MULADD(at[57], at[77]); MULADD(at[58], at[76]); MULADD(at[59], at[75]); MULADD(at[60], at[74]); MULADD(at[61], at[73]); MULADD(at[62], at[72]); MULADD(at[63], at[71]); + COMBA_STORE(C->dp[70]); + /* 71 */ + COMBA_FORWARD; + MULADD(at[8], at[127]); MULADD(at[9], at[126]); MULADD(at[10], at[125]); MULADD(at[11], at[124]); MULADD(at[12], at[123]); MULADD(at[13], at[122]); MULADD(at[14], at[121]); MULADD(at[15], at[120]); MULADD(at[16], at[119]); MULADD(at[17], at[118]); MULADD(at[18], at[117]); MULADD(at[19], at[116]); MULADD(at[20], at[115]); MULADD(at[21], at[114]); MULADD(at[22], at[113]); MULADD(at[23], at[112]); MULADD(at[24], at[111]); MULADD(at[25], at[110]); MULADD(at[26], at[109]); MULADD(at[27], at[108]); MULADD(at[28], at[107]); MULADD(at[29], at[106]); MULADD(at[30], at[105]); MULADD(at[31], at[104]); MULADD(at[32], at[103]); MULADD(at[33], at[102]); MULADD(at[34], at[101]); MULADD(at[35], at[100]); MULADD(at[36], at[99]); MULADD(at[37], at[98]); MULADD(at[38], at[97]); MULADD(at[39], at[96]); MULADD(at[40], at[95]); MULADD(at[41], at[94]); MULADD(at[42], at[93]); MULADD(at[43], at[92]); MULADD(at[44], at[91]); MULADD(at[45], at[90]); MULADD(at[46], at[89]); MULADD(at[47], at[88]); MULADD(at[48], at[87]); MULADD(at[49], at[86]); MULADD(at[50], at[85]); MULADD(at[51], at[84]); MULADD(at[52], at[83]); MULADD(at[53], at[82]); MULADD(at[54], at[81]); MULADD(at[55], at[80]); MULADD(at[56], at[79]); MULADD(at[57], at[78]); MULADD(at[58], at[77]); MULADD(at[59], at[76]); MULADD(at[60], at[75]); MULADD(at[61], at[74]); MULADD(at[62], at[73]); MULADD(at[63], at[72]); + COMBA_STORE(C->dp[71]); + /* 72 */ + COMBA_FORWARD; + MULADD(at[9], at[127]); MULADD(at[10], at[126]); MULADD(at[11], at[125]); MULADD(at[12], at[124]); MULADD(at[13], at[123]); MULADD(at[14], at[122]); MULADD(at[15], at[121]); MULADD(at[16], at[120]); MULADD(at[17], at[119]); MULADD(at[18], at[118]); MULADD(at[19], at[117]); MULADD(at[20], at[116]); MULADD(at[21], at[115]); MULADD(at[22], at[114]); MULADD(at[23], at[113]); MULADD(at[24], at[112]); MULADD(at[25], at[111]); MULADD(at[26], at[110]); MULADD(at[27], at[109]); MULADD(at[28], at[108]); MULADD(at[29], at[107]); MULADD(at[30], at[106]); MULADD(at[31], at[105]); MULADD(at[32], at[104]); MULADD(at[33], at[103]); MULADD(at[34], at[102]); MULADD(at[35], at[101]); MULADD(at[36], at[100]); MULADD(at[37], at[99]); MULADD(at[38], at[98]); MULADD(at[39], at[97]); MULADD(at[40], at[96]); MULADD(at[41], at[95]); MULADD(at[42], at[94]); MULADD(at[43], at[93]); MULADD(at[44], at[92]); MULADD(at[45], at[91]); MULADD(at[46], at[90]); MULADD(at[47], at[89]); MULADD(at[48], at[88]); MULADD(at[49], at[87]); MULADD(at[50], at[86]); MULADD(at[51], at[85]); MULADD(at[52], at[84]); MULADD(at[53], at[83]); MULADD(at[54], at[82]); MULADD(at[55], at[81]); MULADD(at[56], at[80]); MULADD(at[57], at[79]); MULADD(at[58], at[78]); MULADD(at[59], at[77]); MULADD(at[60], at[76]); MULADD(at[61], at[75]); MULADD(at[62], at[74]); MULADD(at[63], at[73]); + COMBA_STORE(C->dp[72]); + /* 73 */ + COMBA_FORWARD; + MULADD(at[10], at[127]); MULADD(at[11], at[126]); MULADD(at[12], at[125]); MULADD(at[13], at[124]); MULADD(at[14], at[123]); MULADD(at[15], at[122]); MULADD(at[16], at[121]); MULADD(at[17], at[120]); MULADD(at[18], at[119]); MULADD(at[19], at[118]); MULADD(at[20], at[117]); MULADD(at[21], at[116]); MULADD(at[22], at[115]); MULADD(at[23], at[114]); MULADD(at[24], at[113]); MULADD(at[25], at[112]); MULADD(at[26], at[111]); MULADD(at[27], at[110]); MULADD(at[28], at[109]); MULADD(at[29], at[108]); MULADD(at[30], at[107]); MULADD(at[31], at[106]); MULADD(at[32], at[105]); MULADD(at[33], at[104]); MULADD(at[34], at[103]); MULADD(at[35], at[102]); MULADD(at[36], at[101]); MULADD(at[37], at[100]); MULADD(at[38], at[99]); MULADD(at[39], at[98]); MULADD(at[40], at[97]); MULADD(at[41], at[96]); MULADD(at[42], at[95]); MULADD(at[43], at[94]); MULADD(at[44], at[93]); MULADD(at[45], at[92]); MULADD(at[46], at[91]); MULADD(at[47], at[90]); MULADD(at[48], at[89]); MULADD(at[49], at[88]); MULADD(at[50], at[87]); MULADD(at[51], at[86]); MULADD(at[52], at[85]); MULADD(at[53], at[84]); MULADD(at[54], at[83]); MULADD(at[55], at[82]); MULADD(at[56], at[81]); MULADD(at[57], at[80]); MULADD(at[58], at[79]); MULADD(at[59], at[78]); MULADD(at[60], at[77]); MULADD(at[61], at[76]); MULADD(at[62], at[75]); MULADD(at[63], at[74]); + COMBA_STORE(C->dp[73]); + /* 74 */ + COMBA_FORWARD; + MULADD(at[11], at[127]); MULADD(at[12], at[126]); MULADD(at[13], at[125]); MULADD(at[14], at[124]); MULADD(at[15], at[123]); MULADD(at[16], at[122]); MULADD(at[17], at[121]); MULADD(at[18], at[120]); MULADD(at[19], at[119]); MULADD(at[20], at[118]); MULADD(at[21], at[117]); MULADD(at[22], at[116]); MULADD(at[23], at[115]); MULADD(at[24], at[114]); MULADD(at[25], at[113]); MULADD(at[26], at[112]); MULADD(at[27], at[111]); MULADD(at[28], at[110]); MULADD(at[29], at[109]); MULADD(at[30], at[108]); MULADD(at[31], at[107]); MULADD(at[32], at[106]); MULADD(at[33], at[105]); MULADD(at[34], at[104]); MULADD(at[35], at[103]); MULADD(at[36], at[102]); MULADD(at[37], at[101]); MULADD(at[38], at[100]); MULADD(at[39], at[99]); MULADD(at[40], at[98]); MULADD(at[41], at[97]); MULADD(at[42], at[96]); MULADD(at[43], at[95]); MULADD(at[44], at[94]); MULADD(at[45], at[93]); MULADD(at[46], at[92]); MULADD(at[47], at[91]); MULADD(at[48], at[90]); MULADD(at[49], at[89]); MULADD(at[50], at[88]); MULADD(at[51], at[87]); MULADD(at[52], at[86]); MULADD(at[53], at[85]); MULADD(at[54], at[84]); MULADD(at[55], at[83]); MULADD(at[56], at[82]); MULADD(at[57], at[81]); MULADD(at[58], at[80]); MULADD(at[59], at[79]); MULADD(at[60], at[78]); MULADD(at[61], at[77]); MULADD(at[62], at[76]); MULADD(at[63], at[75]); + COMBA_STORE(C->dp[74]); + /* 75 */ + COMBA_FORWARD; + MULADD(at[12], at[127]); MULADD(at[13], at[126]); MULADD(at[14], at[125]); MULADD(at[15], at[124]); MULADD(at[16], at[123]); MULADD(at[17], at[122]); MULADD(at[18], at[121]); MULADD(at[19], at[120]); MULADD(at[20], at[119]); MULADD(at[21], at[118]); MULADD(at[22], at[117]); MULADD(at[23], at[116]); MULADD(at[24], at[115]); MULADD(at[25], at[114]); MULADD(at[26], at[113]); MULADD(at[27], at[112]); MULADD(at[28], at[111]); MULADD(at[29], at[110]); MULADD(at[30], at[109]); MULADD(at[31], at[108]); MULADD(at[32], at[107]); MULADD(at[33], at[106]); MULADD(at[34], at[105]); MULADD(at[35], at[104]); MULADD(at[36], at[103]); MULADD(at[37], at[102]); MULADD(at[38], at[101]); MULADD(at[39], at[100]); MULADD(at[40], at[99]); MULADD(at[41], at[98]); MULADD(at[42], at[97]); MULADD(at[43], at[96]); MULADD(at[44], at[95]); MULADD(at[45], at[94]); MULADD(at[46], at[93]); MULADD(at[47], at[92]); MULADD(at[48], at[91]); MULADD(at[49], at[90]); MULADD(at[50], at[89]); MULADD(at[51], at[88]); MULADD(at[52], at[87]); MULADD(at[53], at[86]); MULADD(at[54], at[85]); MULADD(at[55], at[84]); MULADD(at[56], at[83]); MULADD(at[57], at[82]); MULADD(at[58], at[81]); MULADD(at[59], at[80]); MULADD(at[60], at[79]); MULADD(at[61], at[78]); MULADD(at[62], at[77]); MULADD(at[63], at[76]); + COMBA_STORE(C->dp[75]); + /* 76 */ + COMBA_FORWARD; + MULADD(at[13], at[127]); MULADD(at[14], at[126]); MULADD(at[15], at[125]); MULADD(at[16], at[124]); MULADD(at[17], at[123]); MULADD(at[18], at[122]); MULADD(at[19], at[121]); MULADD(at[20], at[120]); MULADD(at[21], at[119]); MULADD(at[22], at[118]); MULADD(at[23], at[117]); MULADD(at[24], at[116]); MULADD(at[25], at[115]); MULADD(at[26], at[114]); MULADD(at[27], at[113]); MULADD(at[28], at[112]); MULADD(at[29], at[111]); MULADD(at[30], at[110]); MULADD(at[31], at[109]); MULADD(at[32], at[108]); MULADD(at[33], at[107]); MULADD(at[34], at[106]); MULADD(at[35], at[105]); MULADD(at[36], at[104]); MULADD(at[37], at[103]); MULADD(at[38], at[102]); MULADD(at[39], at[101]); MULADD(at[40], at[100]); MULADD(at[41], at[99]); MULADD(at[42], at[98]); MULADD(at[43], at[97]); MULADD(at[44], at[96]); MULADD(at[45], at[95]); MULADD(at[46], at[94]); MULADD(at[47], at[93]); MULADD(at[48], at[92]); MULADD(at[49], at[91]); MULADD(at[50], at[90]); MULADD(at[51], at[89]); MULADD(at[52], at[88]); MULADD(at[53], at[87]); MULADD(at[54], at[86]); MULADD(at[55], at[85]); MULADD(at[56], at[84]); MULADD(at[57], at[83]); MULADD(at[58], at[82]); MULADD(at[59], at[81]); MULADD(at[60], at[80]); MULADD(at[61], at[79]); MULADD(at[62], at[78]); MULADD(at[63], at[77]); + COMBA_STORE(C->dp[76]); + /* 77 */ + COMBA_FORWARD; + MULADD(at[14], at[127]); MULADD(at[15], at[126]); MULADD(at[16], at[125]); MULADD(at[17], at[124]); MULADD(at[18], at[123]); MULADD(at[19], at[122]); MULADD(at[20], at[121]); MULADD(at[21], at[120]); MULADD(at[22], at[119]); MULADD(at[23], at[118]); MULADD(at[24], at[117]); MULADD(at[25], at[116]); MULADD(at[26], at[115]); MULADD(at[27], at[114]); MULADD(at[28], at[113]); MULADD(at[29], at[112]); MULADD(at[30], at[111]); MULADD(at[31], at[110]); MULADD(at[32], at[109]); MULADD(at[33], at[108]); MULADD(at[34], at[107]); MULADD(at[35], at[106]); MULADD(at[36], at[105]); MULADD(at[37], at[104]); MULADD(at[38], at[103]); MULADD(at[39], at[102]); MULADD(at[40], at[101]); MULADD(at[41], at[100]); MULADD(at[42], at[99]); MULADD(at[43], at[98]); MULADD(at[44], at[97]); MULADD(at[45], at[96]); MULADD(at[46], at[95]); MULADD(at[47], at[94]); MULADD(at[48], at[93]); MULADD(at[49], at[92]); MULADD(at[50], at[91]); MULADD(at[51], at[90]); MULADD(at[52], at[89]); MULADD(at[53], at[88]); MULADD(at[54], at[87]); MULADD(at[55], at[86]); MULADD(at[56], at[85]); MULADD(at[57], at[84]); MULADD(at[58], at[83]); MULADD(at[59], at[82]); MULADD(at[60], at[81]); MULADD(at[61], at[80]); MULADD(at[62], at[79]); MULADD(at[63], at[78]); + COMBA_STORE(C->dp[77]); + /* 78 */ + COMBA_FORWARD; + MULADD(at[15], at[127]); MULADD(at[16], at[126]); MULADD(at[17], at[125]); MULADD(at[18], at[124]); MULADD(at[19], at[123]); MULADD(at[20], at[122]); MULADD(at[21], at[121]); MULADD(at[22], at[120]); MULADD(at[23], at[119]); MULADD(at[24], at[118]); MULADD(at[25], at[117]); MULADD(at[26], at[116]); MULADD(at[27], at[115]); MULADD(at[28], at[114]); MULADD(at[29], at[113]); MULADD(at[30], at[112]); MULADD(at[31], at[111]); MULADD(at[32], at[110]); MULADD(at[33], at[109]); MULADD(at[34], at[108]); MULADD(at[35], at[107]); MULADD(at[36], at[106]); MULADD(at[37], at[105]); MULADD(at[38], at[104]); MULADD(at[39], at[103]); MULADD(at[40], at[102]); MULADD(at[41], at[101]); MULADD(at[42], at[100]); MULADD(at[43], at[99]); MULADD(at[44], at[98]); MULADD(at[45], at[97]); MULADD(at[46], at[96]); MULADD(at[47], at[95]); MULADD(at[48], at[94]); MULADD(at[49], at[93]); MULADD(at[50], at[92]); MULADD(at[51], at[91]); MULADD(at[52], at[90]); MULADD(at[53], at[89]); MULADD(at[54], at[88]); MULADD(at[55], at[87]); MULADD(at[56], at[86]); MULADD(at[57], at[85]); MULADD(at[58], at[84]); MULADD(at[59], at[83]); MULADD(at[60], at[82]); MULADD(at[61], at[81]); MULADD(at[62], at[80]); MULADD(at[63], at[79]); + COMBA_STORE(C->dp[78]); + /* 79 */ + COMBA_FORWARD; + MULADD(at[16], at[127]); MULADD(at[17], at[126]); MULADD(at[18], at[125]); MULADD(at[19], at[124]); MULADD(at[20], at[123]); MULADD(at[21], at[122]); MULADD(at[22], at[121]); MULADD(at[23], at[120]); MULADD(at[24], at[119]); MULADD(at[25], at[118]); MULADD(at[26], at[117]); MULADD(at[27], at[116]); MULADD(at[28], at[115]); MULADD(at[29], at[114]); MULADD(at[30], at[113]); MULADD(at[31], at[112]); MULADD(at[32], at[111]); MULADD(at[33], at[110]); MULADD(at[34], at[109]); MULADD(at[35], at[108]); MULADD(at[36], at[107]); MULADD(at[37], at[106]); MULADD(at[38], at[105]); MULADD(at[39], at[104]); MULADD(at[40], at[103]); MULADD(at[41], at[102]); MULADD(at[42], at[101]); MULADD(at[43], at[100]); MULADD(at[44], at[99]); MULADD(at[45], at[98]); MULADD(at[46], at[97]); MULADD(at[47], at[96]); MULADD(at[48], at[95]); MULADD(at[49], at[94]); MULADD(at[50], at[93]); MULADD(at[51], at[92]); MULADD(at[52], at[91]); MULADD(at[53], at[90]); MULADD(at[54], at[89]); MULADD(at[55], at[88]); MULADD(at[56], at[87]); MULADD(at[57], at[86]); MULADD(at[58], at[85]); MULADD(at[59], at[84]); MULADD(at[60], at[83]); MULADD(at[61], at[82]); MULADD(at[62], at[81]); MULADD(at[63], at[80]); + COMBA_STORE(C->dp[79]); + /* 80 */ + COMBA_FORWARD; + MULADD(at[17], at[127]); MULADD(at[18], at[126]); MULADD(at[19], at[125]); MULADD(at[20], at[124]); MULADD(at[21], at[123]); MULADD(at[22], at[122]); MULADD(at[23], at[121]); MULADD(at[24], at[120]); MULADD(at[25], at[119]); MULADD(at[26], at[118]); MULADD(at[27], at[117]); MULADD(at[28], at[116]); MULADD(at[29], at[115]); MULADD(at[30], at[114]); MULADD(at[31], at[113]); MULADD(at[32], at[112]); MULADD(at[33], at[111]); MULADD(at[34], at[110]); MULADD(at[35], at[109]); MULADD(at[36], at[108]); MULADD(at[37], at[107]); MULADD(at[38], at[106]); MULADD(at[39], at[105]); MULADD(at[40], at[104]); MULADD(at[41], at[103]); MULADD(at[42], at[102]); MULADD(at[43], at[101]); MULADD(at[44], at[100]); MULADD(at[45], at[99]); MULADD(at[46], at[98]); MULADD(at[47], at[97]); MULADD(at[48], at[96]); MULADD(at[49], at[95]); MULADD(at[50], at[94]); MULADD(at[51], at[93]); MULADD(at[52], at[92]); MULADD(at[53], at[91]); MULADD(at[54], at[90]); MULADD(at[55], at[89]); MULADD(at[56], at[88]); MULADD(at[57], at[87]); MULADD(at[58], at[86]); MULADD(at[59], at[85]); MULADD(at[60], at[84]); MULADD(at[61], at[83]); MULADD(at[62], at[82]); MULADD(at[63], at[81]); + COMBA_STORE(C->dp[80]); + /* 81 */ + COMBA_FORWARD; + MULADD(at[18], at[127]); MULADD(at[19], at[126]); MULADD(at[20], at[125]); MULADD(at[21], at[124]); MULADD(at[22], at[123]); MULADD(at[23], at[122]); MULADD(at[24], at[121]); MULADD(at[25], at[120]); MULADD(at[26], at[119]); MULADD(at[27], at[118]); MULADD(at[28], at[117]); MULADD(at[29], at[116]); MULADD(at[30], at[115]); MULADD(at[31], at[114]); MULADD(at[32], at[113]); MULADD(at[33], at[112]); MULADD(at[34], at[111]); MULADD(at[35], at[110]); MULADD(at[36], at[109]); MULADD(at[37], at[108]); MULADD(at[38], at[107]); MULADD(at[39], at[106]); MULADD(at[40], at[105]); MULADD(at[41], at[104]); MULADD(at[42], at[103]); MULADD(at[43], at[102]); MULADD(at[44], at[101]); MULADD(at[45], at[100]); MULADD(at[46], at[99]); MULADD(at[47], at[98]); MULADD(at[48], at[97]); MULADD(at[49], at[96]); MULADD(at[50], at[95]); MULADD(at[51], at[94]); MULADD(at[52], at[93]); MULADD(at[53], at[92]); MULADD(at[54], at[91]); MULADD(at[55], at[90]); MULADD(at[56], at[89]); MULADD(at[57], at[88]); MULADD(at[58], at[87]); MULADD(at[59], at[86]); MULADD(at[60], at[85]); MULADD(at[61], at[84]); MULADD(at[62], at[83]); MULADD(at[63], at[82]); + COMBA_STORE(C->dp[81]); + /* 82 */ + COMBA_FORWARD; + MULADD(at[19], at[127]); MULADD(at[20], at[126]); MULADD(at[21], at[125]); MULADD(at[22], at[124]); MULADD(at[23], at[123]); MULADD(at[24], at[122]); MULADD(at[25], at[121]); MULADD(at[26], at[120]); MULADD(at[27], at[119]); MULADD(at[28], at[118]); MULADD(at[29], at[117]); MULADD(at[30], at[116]); MULADD(at[31], at[115]); MULADD(at[32], at[114]); MULADD(at[33], at[113]); MULADD(at[34], at[112]); MULADD(at[35], at[111]); MULADD(at[36], at[110]); MULADD(at[37], at[109]); MULADD(at[38], at[108]); MULADD(at[39], at[107]); MULADD(at[40], at[106]); MULADD(at[41], at[105]); MULADD(at[42], at[104]); MULADD(at[43], at[103]); MULADD(at[44], at[102]); MULADD(at[45], at[101]); MULADD(at[46], at[100]); MULADD(at[47], at[99]); MULADD(at[48], at[98]); MULADD(at[49], at[97]); MULADD(at[50], at[96]); MULADD(at[51], at[95]); MULADD(at[52], at[94]); MULADD(at[53], at[93]); MULADD(at[54], at[92]); MULADD(at[55], at[91]); MULADD(at[56], at[90]); MULADD(at[57], at[89]); MULADD(at[58], at[88]); MULADD(at[59], at[87]); MULADD(at[60], at[86]); MULADD(at[61], at[85]); MULADD(at[62], at[84]); MULADD(at[63], at[83]); + COMBA_STORE(C->dp[82]); + /* 83 */ + COMBA_FORWARD; + MULADD(at[20], at[127]); MULADD(at[21], at[126]); MULADD(at[22], at[125]); MULADD(at[23], at[124]); MULADD(at[24], at[123]); MULADD(at[25], at[122]); MULADD(at[26], at[121]); MULADD(at[27], at[120]); MULADD(at[28], at[119]); MULADD(at[29], at[118]); MULADD(at[30], at[117]); MULADD(at[31], at[116]); MULADD(at[32], at[115]); MULADD(at[33], at[114]); MULADD(at[34], at[113]); MULADD(at[35], at[112]); MULADD(at[36], at[111]); MULADD(at[37], at[110]); MULADD(at[38], at[109]); MULADD(at[39], at[108]); MULADD(at[40], at[107]); MULADD(at[41], at[106]); MULADD(at[42], at[105]); MULADD(at[43], at[104]); MULADD(at[44], at[103]); MULADD(at[45], at[102]); MULADD(at[46], at[101]); MULADD(at[47], at[100]); MULADD(at[48], at[99]); MULADD(at[49], at[98]); MULADD(at[50], at[97]); MULADD(at[51], at[96]); MULADD(at[52], at[95]); MULADD(at[53], at[94]); MULADD(at[54], at[93]); MULADD(at[55], at[92]); MULADD(at[56], at[91]); MULADD(at[57], at[90]); MULADD(at[58], at[89]); MULADD(at[59], at[88]); MULADD(at[60], at[87]); MULADD(at[61], at[86]); MULADD(at[62], at[85]); MULADD(at[63], at[84]); + COMBA_STORE(C->dp[83]); + /* 84 */ + COMBA_FORWARD; + MULADD(at[21], at[127]); MULADD(at[22], at[126]); MULADD(at[23], at[125]); MULADD(at[24], at[124]); MULADD(at[25], at[123]); MULADD(at[26], at[122]); MULADD(at[27], at[121]); MULADD(at[28], at[120]); MULADD(at[29], at[119]); MULADD(at[30], at[118]); MULADD(at[31], at[117]); MULADD(at[32], at[116]); MULADD(at[33], at[115]); MULADD(at[34], at[114]); MULADD(at[35], at[113]); MULADD(at[36], at[112]); MULADD(at[37], at[111]); MULADD(at[38], at[110]); MULADD(at[39], at[109]); MULADD(at[40], at[108]); MULADD(at[41], at[107]); MULADD(at[42], at[106]); MULADD(at[43], at[105]); MULADD(at[44], at[104]); MULADD(at[45], at[103]); MULADD(at[46], at[102]); MULADD(at[47], at[101]); MULADD(at[48], at[100]); MULADD(at[49], at[99]); MULADD(at[50], at[98]); MULADD(at[51], at[97]); MULADD(at[52], at[96]); MULADD(at[53], at[95]); MULADD(at[54], at[94]); MULADD(at[55], at[93]); MULADD(at[56], at[92]); MULADD(at[57], at[91]); MULADD(at[58], at[90]); MULADD(at[59], at[89]); MULADD(at[60], at[88]); MULADD(at[61], at[87]); MULADD(at[62], at[86]); MULADD(at[63], at[85]); + COMBA_STORE(C->dp[84]); + /* 85 */ + COMBA_FORWARD; + MULADD(at[22], at[127]); MULADD(at[23], at[126]); MULADD(at[24], at[125]); MULADD(at[25], at[124]); MULADD(at[26], at[123]); MULADD(at[27], at[122]); MULADD(at[28], at[121]); MULADD(at[29], at[120]); MULADD(at[30], at[119]); MULADD(at[31], at[118]); MULADD(at[32], at[117]); MULADD(at[33], at[116]); MULADD(at[34], at[115]); MULADD(at[35], at[114]); MULADD(at[36], at[113]); MULADD(at[37], at[112]); MULADD(at[38], at[111]); MULADD(at[39], at[110]); MULADD(at[40], at[109]); MULADD(at[41], at[108]); MULADD(at[42], at[107]); MULADD(at[43], at[106]); MULADD(at[44], at[105]); MULADD(at[45], at[104]); MULADD(at[46], at[103]); MULADD(at[47], at[102]); MULADD(at[48], at[101]); MULADD(at[49], at[100]); MULADD(at[50], at[99]); MULADD(at[51], at[98]); MULADD(at[52], at[97]); MULADD(at[53], at[96]); MULADD(at[54], at[95]); MULADD(at[55], at[94]); MULADD(at[56], at[93]); MULADD(at[57], at[92]); MULADD(at[58], at[91]); MULADD(at[59], at[90]); MULADD(at[60], at[89]); MULADD(at[61], at[88]); MULADD(at[62], at[87]); MULADD(at[63], at[86]); + COMBA_STORE(C->dp[85]); + /* 86 */ + COMBA_FORWARD; + MULADD(at[23], at[127]); MULADD(at[24], at[126]); MULADD(at[25], at[125]); MULADD(at[26], at[124]); MULADD(at[27], at[123]); MULADD(at[28], at[122]); MULADD(at[29], at[121]); MULADD(at[30], at[120]); MULADD(at[31], at[119]); MULADD(at[32], at[118]); MULADD(at[33], at[117]); MULADD(at[34], at[116]); MULADD(at[35], at[115]); MULADD(at[36], at[114]); MULADD(at[37], at[113]); MULADD(at[38], at[112]); MULADD(at[39], at[111]); MULADD(at[40], at[110]); MULADD(at[41], at[109]); MULADD(at[42], at[108]); MULADD(at[43], at[107]); MULADD(at[44], at[106]); MULADD(at[45], at[105]); MULADD(at[46], at[104]); MULADD(at[47], at[103]); MULADD(at[48], at[102]); MULADD(at[49], at[101]); MULADD(at[50], at[100]); MULADD(at[51], at[99]); MULADD(at[52], at[98]); MULADD(at[53], at[97]); MULADD(at[54], at[96]); MULADD(at[55], at[95]); MULADD(at[56], at[94]); MULADD(at[57], at[93]); MULADD(at[58], at[92]); MULADD(at[59], at[91]); MULADD(at[60], at[90]); MULADD(at[61], at[89]); MULADD(at[62], at[88]); MULADD(at[63], at[87]); + COMBA_STORE(C->dp[86]); + /* 87 */ + COMBA_FORWARD; + MULADD(at[24], at[127]); MULADD(at[25], at[126]); MULADD(at[26], at[125]); MULADD(at[27], at[124]); MULADD(at[28], at[123]); MULADD(at[29], at[122]); MULADD(at[30], at[121]); MULADD(at[31], at[120]); MULADD(at[32], at[119]); MULADD(at[33], at[118]); MULADD(at[34], at[117]); MULADD(at[35], at[116]); MULADD(at[36], at[115]); MULADD(at[37], at[114]); MULADD(at[38], at[113]); MULADD(at[39], at[112]); MULADD(at[40], at[111]); MULADD(at[41], at[110]); MULADD(at[42], at[109]); MULADD(at[43], at[108]); MULADD(at[44], at[107]); MULADD(at[45], at[106]); MULADD(at[46], at[105]); MULADD(at[47], at[104]); MULADD(at[48], at[103]); MULADD(at[49], at[102]); MULADD(at[50], at[101]); MULADD(at[51], at[100]); MULADD(at[52], at[99]); MULADD(at[53], at[98]); MULADD(at[54], at[97]); MULADD(at[55], at[96]); MULADD(at[56], at[95]); MULADD(at[57], at[94]); MULADD(at[58], at[93]); MULADD(at[59], at[92]); MULADD(at[60], at[91]); MULADD(at[61], at[90]); MULADD(at[62], at[89]); MULADD(at[63], at[88]); + COMBA_STORE(C->dp[87]); + /* 88 */ + COMBA_FORWARD; + MULADD(at[25], at[127]); MULADD(at[26], at[126]); MULADD(at[27], at[125]); MULADD(at[28], at[124]); MULADD(at[29], at[123]); MULADD(at[30], at[122]); MULADD(at[31], at[121]); MULADD(at[32], at[120]); MULADD(at[33], at[119]); MULADD(at[34], at[118]); MULADD(at[35], at[117]); MULADD(at[36], at[116]); MULADD(at[37], at[115]); MULADD(at[38], at[114]); MULADD(at[39], at[113]); MULADD(at[40], at[112]); MULADD(at[41], at[111]); MULADD(at[42], at[110]); MULADD(at[43], at[109]); MULADD(at[44], at[108]); MULADD(at[45], at[107]); MULADD(at[46], at[106]); MULADD(at[47], at[105]); MULADD(at[48], at[104]); MULADD(at[49], at[103]); MULADD(at[50], at[102]); MULADD(at[51], at[101]); MULADD(at[52], at[100]); MULADD(at[53], at[99]); MULADD(at[54], at[98]); MULADD(at[55], at[97]); MULADD(at[56], at[96]); MULADD(at[57], at[95]); MULADD(at[58], at[94]); MULADD(at[59], at[93]); MULADD(at[60], at[92]); MULADD(at[61], at[91]); MULADD(at[62], at[90]); MULADD(at[63], at[89]); + COMBA_STORE(C->dp[88]); + /* 89 */ + COMBA_FORWARD; + MULADD(at[26], at[127]); MULADD(at[27], at[126]); MULADD(at[28], at[125]); MULADD(at[29], at[124]); MULADD(at[30], at[123]); MULADD(at[31], at[122]); MULADD(at[32], at[121]); MULADD(at[33], at[120]); MULADD(at[34], at[119]); MULADD(at[35], at[118]); MULADD(at[36], at[117]); MULADD(at[37], at[116]); MULADD(at[38], at[115]); MULADD(at[39], at[114]); MULADD(at[40], at[113]); MULADD(at[41], at[112]); MULADD(at[42], at[111]); MULADD(at[43], at[110]); MULADD(at[44], at[109]); MULADD(at[45], at[108]); MULADD(at[46], at[107]); MULADD(at[47], at[106]); MULADD(at[48], at[105]); MULADD(at[49], at[104]); MULADD(at[50], at[103]); MULADD(at[51], at[102]); MULADD(at[52], at[101]); MULADD(at[53], at[100]); MULADD(at[54], at[99]); MULADD(at[55], at[98]); MULADD(at[56], at[97]); MULADD(at[57], at[96]); MULADD(at[58], at[95]); MULADD(at[59], at[94]); MULADD(at[60], at[93]); MULADD(at[61], at[92]); MULADD(at[62], at[91]); MULADD(at[63], at[90]); + COMBA_STORE(C->dp[89]); + /* 90 */ + COMBA_FORWARD; + MULADD(at[27], at[127]); MULADD(at[28], at[126]); MULADD(at[29], at[125]); MULADD(at[30], at[124]); MULADD(at[31], at[123]); MULADD(at[32], at[122]); MULADD(at[33], at[121]); MULADD(at[34], at[120]); MULADD(at[35], at[119]); MULADD(at[36], at[118]); MULADD(at[37], at[117]); MULADD(at[38], at[116]); MULADD(at[39], at[115]); MULADD(at[40], at[114]); MULADD(at[41], at[113]); MULADD(at[42], at[112]); MULADD(at[43], at[111]); MULADD(at[44], at[110]); MULADD(at[45], at[109]); MULADD(at[46], at[108]); MULADD(at[47], at[107]); MULADD(at[48], at[106]); MULADD(at[49], at[105]); MULADD(at[50], at[104]); MULADD(at[51], at[103]); MULADD(at[52], at[102]); MULADD(at[53], at[101]); MULADD(at[54], at[100]); MULADD(at[55], at[99]); MULADD(at[56], at[98]); MULADD(at[57], at[97]); MULADD(at[58], at[96]); MULADD(at[59], at[95]); MULADD(at[60], at[94]); MULADD(at[61], at[93]); MULADD(at[62], at[92]); MULADD(at[63], at[91]); + COMBA_STORE(C->dp[90]); + /* 91 */ + COMBA_FORWARD; + MULADD(at[28], at[127]); MULADD(at[29], at[126]); MULADD(at[30], at[125]); MULADD(at[31], at[124]); MULADD(at[32], at[123]); MULADD(at[33], at[122]); MULADD(at[34], at[121]); MULADD(at[35], at[120]); MULADD(at[36], at[119]); MULADD(at[37], at[118]); MULADD(at[38], at[117]); MULADD(at[39], at[116]); MULADD(at[40], at[115]); MULADD(at[41], at[114]); MULADD(at[42], at[113]); MULADD(at[43], at[112]); MULADD(at[44], at[111]); MULADD(at[45], at[110]); MULADD(at[46], at[109]); MULADD(at[47], at[108]); MULADD(at[48], at[107]); MULADD(at[49], at[106]); MULADD(at[50], at[105]); MULADD(at[51], at[104]); MULADD(at[52], at[103]); MULADD(at[53], at[102]); MULADD(at[54], at[101]); MULADD(at[55], at[100]); MULADD(at[56], at[99]); MULADD(at[57], at[98]); MULADD(at[58], at[97]); MULADD(at[59], at[96]); MULADD(at[60], at[95]); MULADD(at[61], at[94]); MULADD(at[62], at[93]); MULADD(at[63], at[92]); + COMBA_STORE(C->dp[91]); + /* 92 */ + COMBA_FORWARD; + MULADD(at[29], at[127]); MULADD(at[30], at[126]); MULADD(at[31], at[125]); MULADD(at[32], at[124]); MULADD(at[33], at[123]); MULADD(at[34], at[122]); MULADD(at[35], at[121]); MULADD(at[36], at[120]); MULADD(at[37], at[119]); MULADD(at[38], at[118]); MULADD(at[39], at[117]); MULADD(at[40], at[116]); MULADD(at[41], at[115]); MULADD(at[42], at[114]); MULADD(at[43], at[113]); MULADD(at[44], at[112]); MULADD(at[45], at[111]); MULADD(at[46], at[110]); MULADD(at[47], at[109]); MULADD(at[48], at[108]); MULADD(at[49], at[107]); MULADD(at[50], at[106]); MULADD(at[51], at[105]); MULADD(at[52], at[104]); MULADD(at[53], at[103]); MULADD(at[54], at[102]); MULADD(at[55], at[101]); MULADD(at[56], at[100]); MULADD(at[57], at[99]); MULADD(at[58], at[98]); MULADD(at[59], at[97]); MULADD(at[60], at[96]); MULADD(at[61], at[95]); MULADD(at[62], at[94]); MULADD(at[63], at[93]); + COMBA_STORE(C->dp[92]); + /* 93 */ + COMBA_FORWARD; + MULADD(at[30], at[127]); MULADD(at[31], at[126]); MULADD(at[32], at[125]); MULADD(at[33], at[124]); MULADD(at[34], at[123]); MULADD(at[35], at[122]); MULADD(at[36], at[121]); MULADD(at[37], at[120]); MULADD(at[38], at[119]); MULADD(at[39], at[118]); MULADD(at[40], at[117]); MULADD(at[41], at[116]); MULADD(at[42], at[115]); MULADD(at[43], at[114]); MULADD(at[44], at[113]); MULADD(at[45], at[112]); MULADD(at[46], at[111]); MULADD(at[47], at[110]); MULADD(at[48], at[109]); MULADD(at[49], at[108]); MULADD(at[50], at[107]); MULADD(at[51], at[106]); MULADD(at[52], at[105]); MULADD(at[53], at[104]); MULADD(at[54], at[103]); MULADD(at[55], at[102]); MULADD(at[56], at[101]); MULADD(at[57], at[100]); MULADD(at[58], at[99]); MULADD(at[59], at[98]); MULADD(at[60], at[97]); MULADD(at[61], at[96]); MULADD(at[62], at[95]); MULADD(at[63], at[94]); + COMBA_STORE(C->dp[93]); + /* 94 */ + COMBA_FORWARD; + MULADD(at[31], at[127]); MULADD(at[32], at[126]); MULADD(at[33], at[125]); MULADD(at[34], at[124]); MULADD(at[35], at[123]); MULADD(at[36], at[122]); MULADD(at[37], at[121]); MULADD(at[38], at[120]); MULADD(at[39], at[119]); MULADD(at[40], at[118]); MULADD(at[41], at[117]); MULADD(at[42], at[116]); MULADD(at[43], at[115]); MULADD(at[44], at[114]); MULADD(at[45], at[113]); MULADD(at[46], at[112]); MULADD(at[47], at[111]); MULADD(at[48], at[110]); MULADD(at[49], at[109]); MULADD(at[50], at[108]); MULADD(at[51], at[107]); MULADD(at[52], at[106]); MULADD(at[53], at[105]); MULADD(at[54], at[104]); MULADD(at[55], at[103]); MULADD(at[56], at[102]); MULADD(at[57], at[101]); MULADD(at[58], at[100]); MULADD(at[59], at[99]); MULADD(at[60], at[98]); MULADD(at[61], at[97]); MULADD(at[62], at[96]); MULADD(at[63], at[95]); + COMBA_STORE(C->dp[94]); + /* 95 */ + COMBA_FORWARD; + MULADD(at[32], at[127]); MULADD(at[33], at[126]); MULADD(at[34], at[125]); MULADD(at[35], at[124]); MULADD(at[36], at[123]); MULADD(at[37], at[122]); MULADD(at[38], at[121]); MULADD(at[39], at[120]); MULADD(at[40], at[119]); MULADD(at[41], at[118]); MULADD(at[42], at[117]); MULADD(at[43], at[116]); MULADD(at[44], at[115]); MULADD(at[45], at[114]); MULADD(at[46], at[113]); MULADD(at[47], at[112]); MULADD(at[48], at[111]); MULADD(at[49], at[110]); MULADD(at[50], at[109]); MULADD(at[51], at[108]); MULADD(at[52], at[107]); MULADD(at[53], at[106]); MULADD(at[54], at[105]); MULADD(at[55], at[104]); MULADD(at[56], at[103]); MULADD(at[57], at[102]); MULADD(at[58], at[101]); MULADD(at[59], at[100]); MULADD(at[60], at[99]); MULADD(at[61], at[98]); MULADD(at[62], at[97]); MULADD(at[63], at[96]); + COMBA_STORE(C->dp[95]); + /* 96 */ + COMBA_FORWARD; + MULADD(at[33], at[127]); MULADD(at[34], at[126]); MULADD(at[35], at[125]); MULADD(at[36], at[124]); MULADD(at[37], at[123]); MULADD(at[38], at[122]); MULADD(at[39], at[121]); MULADD(at[40], at[120]); MULADD(at[41], at[119]); MULADD(at[42], at[118]); MULADD(at[43], at[117]); MULADD(at[44], at[116]); MULADD(at[45], at[115]); MULADD(at[46], at[114]); MULADD(at[47], at[113]); MULADD(at[48], at[112]); MULADD(at[49], at[111]); MULADD(at[50], at[110]); MULADD(at[51], at[109]); MULADD(at[52], at[108]); MULADD(at[53], at[107]); MULADD(at[54], at[106]); MULADD(at[55], at[105]); MULADD(at[56], at[104]); MULADD(at[57], at[103]); MULADD(at[58], at[102]); MULADD(at[59], at[101]); MULADD(at[60], at[100]); MULADD(at[61], at[99]); MULADD(at[62], at[98]); MULADD(at[63], at[97]); + COMBA_STORE(C->dp[96]); + /* 97 */ + COMBA_FORWARD; + MULADD(at[34], at[127]); MULADD(at[35], at[126]); MULADD(at[36], at[125]); MULADD(at[37], at[124]); MULADD(at[38], at[123]); MULADD(at[39], at[122]); MULADD(at[40], at[121]); MULADD(at[41], at[120]); MULADD(at[42], at[119]); MULADD(at[43], at[118]); MULADD(at[44], at[117]); MULADD(at[45], at[116]); MULADD(at[46], at[115]); MULADD(at[47], at[114]); MULADD(at[48], at[113]); MULADD(at[49], at[112]); MULADD(at[50], at[111]); MULADD(at[51], at[110]); MULADD(at[52], at[109]); MULADD(at[53], at[108]); MULADD(at[54], at[107]); MULADD(at[55], at[106]); MULADD(at[56], at[105]); MULADD(at[57], at[104]); MULADD(at[58], at[103]); MULADD(at[59], at[102]); MULADD(at[60], at[101]); MULADD(at[61], at[100]); MULADD(at[62], at[99]); MULADD(at[63], at[98]); + COMBA_STORE(C->dp[97]); + /* 98 */ + COMBA_FORWARD; + MULADD(at[35], at[127]); MULADD(at[36], at[126]); MULADD(at[37], at[125]); MULADD(at[38], at[124]); MULADD(at[39], at[123]); MULADD(at[40], at[122]); MULADD(at[41], at[121]); MULADD(at[42], at[120]); MULADD(at[43], at[119]); MULADD(at[44], at[118]); MULADD(at[45], at[117]); MULADD(at[46], at[116]); MULADD(at[47], at[115]); MULADD(at[48], at[114]); MULADD(at[49], at[113]); MULADD(at[50], at[112]); MULADD(at[51], at[111]); MULADD(at[52], at[110]); MULADD(at[53], at[109]); MULADD(at[54], at[108]); MULADD(at[55], at[107]); MULADD(at[56], at[106]); MULADD(at[57], at[105]); MULADD(at[58], at[104]); MULADD(at[59], at[103]); MULADD(at[60], at[102]); MULADD(at[61], at[101]); MULADD(at[62], at[100]); MULADD(at[63], at[99]); + COMBA_STORE(C->dp[98]); + /* 99 */ + COMBA_FORWARD; + MULADD(at[36], at[127]); MULADD(at[37], at[126]); MULADD(at[38], at[125]); MULADD(at[39], at[124]); MULADD(at[40], at[123]); MULADD(at[41], at[122]); MULADD(at[42], at[121]); MULADD(at[43], at[120]); MULADD(at[44], at[119]); MULADD(at[45], at[118]); MULADD(at[46], at[117]); MULADD(at[47], at[116]); MULADD(at[48], at[115]); MULADD(at[49], at[114]); MULADD(at[50], at[113]); MULADD(at[51], at[112]); MULADD(at[52], at[111]); MULADD(at[53], at[110]); MULADD(at[54], at[109]); MULADD(at[55], at[108]); MULADD(at[56], at[107]); MULADD(at[57], at[106]); MULADD(at[58], at[105]); MULADD(at[59], at[104]); MULADD(at[60], at[103]); MULADD(at[61], at[102]); MULADD(at[62], at[101]); MULADD(at[63], at[100]); + COMBA_STORE(C->dp[99]); + /* 100 */ + COMBA_FORWARD; + MULADD(at[37], at[127]); MULADD(at[38], at[126]); MULADD(at[39], at[125]); MULADD(at[40], at[124]); MULADD(at[41], at[123]); MULADD(at[42], at[122]); MULADD(at[43], at[121]); MULADD(at[44], at[120]); MULADD(at[45], at[119]); MULADD(at[46], at[118]); MULADD(at[47], at[117]); MULADD(at[48], at[116]); MULADD(at[49], at[115]); MULADD(at[50], at[114]); MULADD(at[51], at[113]); MULADD(at[52], at[112]); MULADD(at[53], at[111]); MULADD(at[54], at[110]); MULADD(at[55], at[109]); MULADD(at[56], at[108]); MULADD(at[57], at[107]); MULADD(at[58], at[106]); MULADD(at[59], at[105]); MULADD(at[60], at[104]); MULADD(at[61], at[103]); MULADD(at[62], at[102]); MULADD(at[63], at[101]); + COMBA_STORE(C->dp[100]); + /* 101 */ + COMBA_FORWARD; + MULADD(at[38], at[127]); MULADD(at[39], at[126]); MULADD(at[40], at[125]); MULADD(at[41], at[124]); MULADD(at[42], at[123]); MULADD(at[43], at[122]); MULADD(at[44], at[121]); MULADD(at[45], at[120]); MULADD(at[46], at[119]); MULADD(at[47], at[118]); MULADD(at[48], at[117]); MULADD(at[49], at[116]); MULADD(at[50], at[115]); MULADD(at[51], at[114]); MULADD(at[52], at[113]); MULADD(at[53], at[112]); MULADD(at[54], at[111]); MULADD(at[55], at[110]); MULADD(at[56], at[109]); MULADD(at[57], at[108]); MULADD(at[58], at[107]); MULADD(at[59], at[106]); MULADD(at[60], at[105]); MULADD(at[61], at[104]); MULADD(at[62], at[103]); MULADD(at[63], at[102]); + COMBA_STORE(C->dp[101]); + /* 102 */ + COMBA_FORWARD; + MULADD(at[39], at[127]); MULADD(at[40], at[126]); MULADD(at[41], at[125]); MULADD(at[42], at[124]); MULADD(at[43], at[123]); MULADD(at[44], at[122]); MULADD(at[45], at[121]); MULADD(at[46], at[120]); MULADD(at[47], at[119]); MULADD(at[48], at[118]); MULADD(at[49], at[117]); MULADD(at[50], at[116]); MULADD(at[51], at[115]); MULADD(at[52], at[114]); MULADD(at[53], at[113]); MULADD(at[54], at[112]); MULADD(at[55], at[111]); MULADD(at[56], at[110]); MULADD(at[57], at[109]); MULADD(at[58], at[108]); MULADD(at[59], at[107]); MULADD(at[60], at[106]); MULADD(at[61], at[105]); MULADD(at[62], at[104]); MULADD(at[63], at[103]); + COMBA_STORE(C->dp[102]); + /* 103 */ + COMBA_FORWARD; + MULADD(at[40], at[127]); MULADD(at[41], at[126]); MULADD(at[42], at[125]); MULADD(at[43], at[124]); MULADD(at[44], at[123]); MULADD(at[45], at[122]); MULADD(at[46], at[121]); MULADD(at[47], at[120]); MULADD(at[48], at[119]); MULADD(at[49], at[118]); MULADD(at[50], at[117]); MULADD(at[51], at[116]); MULADD(at[52], at[115]); MULADD(at[53], at[114]); MULADD(at[54], at[113]); MULADD(at[55], at[112]); MULADD(at[56], at[111]); MULADD(at[57], at[110]); MULADD(at[58], at[109]); MULADD(at[59], at[108]); MULADD(at[60], at[107]); MULADD(at[61], at[106]); MULADD(at[62], at[105]); MULADD(at[63], at[104]); + COMBA_STORE(C->dp[103]); + /* 104 */ + COMBA_FORWARD; + MULADD(at[41], at[127]); MULADD(at[42], at[126]); MULADD(at[43], at[125]); MULADD(at[44], at[124]); MULADD(at[45], at[123]); MULADD(at[46], at[122]); MULADD(at[47], at[121]); MULADD(at[48], at[120]); MULADD(at[49], at[119]); MULADD(at[50], at[118]); MULADD(at[51], at[117]); MULADD(at[52], at[116]); MULADD(at[53], at[115]); MULADD(at[54], at[114]); MULADD(at[55], at[113]); MULADD(at[56], at[112]); MULADD(at[57], at[111]); MULADD(at[58], at[110]); MULADD(at[59], at[109]); MULADD(at[60], at[108]); MULADD(at[61], at[107]); MULADD(at[62], at[106]); MULADD(at[63], at[105]); + COMBA_STORE(C->dp[104]); + /* 105 */ + COMBA_FORWARD; + MULADD(at[42], at[127]); MULADD(at[43], at[126]); MULADD(at[44], at[125]); MULADD(at[45], at[124]); MULADD(at[46], at[123]); MULADD(at[47], at[122]); MULADD(at[48], at[121]); MULADD(at[49], at[120]); MULADD(at[50], at[119]); MULADD(at[51], at[118]); MULADD(at[52], at[117]); MULADD(at[53], at[116]); MULADD(at[54], at[115]); MULADD(at[55], at[114]); MULADD(at[56], at[113]); MULADD(at[57], at[112]); MULADD(at[58], at[111]); MULADD(at[59], at[110]); MULADD(at[60], at[109]); MULADD(at[61], at[108]); MULADD(at[62], at[107]); MULADD(at[63], at[106]); + COMBA_STORE(C->dp[105]); + /* 106 */ + COMBA_FORWARD; + MULADD(at[43], at[127]); MULADD(at[44], at[126]); MULADD(at[45], at[125]); MULADD(at[46], at[124]); MULADD(at[47], at[123]); MULADD(at[48], at[122]); MULADD(at[49], at[121]); MULADD(at[50], at[120]); MULADD(at[51], at[119]); MULADD(at[52], at[118]); MULADD(at[53], at[117]); MULADD(at[54], at[116]); MULADD(at[55], at[115]); MULADD(at[56], at[114]); MULADD(at[57], at[113]); MULADD(at[58], at[112]); MULADD(at[59], at[111]); MULADD(at[60], at[110]); MULADD(at[61], at[109]); MULADD(at[62], at[108]); MULADD(at[63], at[107]); + COMBA_STORE(C->dp[106]); + /* 107 */ + COMBA_FORWARD; + MULADD(at[44], at[127]); MULADD(at[45], at[126]); MULADD(at[46], at[125]); MULADD(at[47], at[124]); MULADD(at[48], at[123]); MULADD(at[49], at[122]); MULADD(at[50], at[121]); MULADD(at[51], at[120]); MULADD(at[52], at[119]); MULADD(at[53], at[118]); MULADD(at[54], at[117]); MULADD(at[55], at[116]); MULADD(at[56], at[115]); MULADD(at[57], at[114]); MULADD(at[58], at[113]); MULADD(at[59], at[112]); MULADD(at[60], at[111]); MULADD(at[61], at[110]); MULADD(at[62], at[109]); MULADD(at[63], at[108]); + COMBA_STORE(C->dp[107]); + /* 108 */ + COMBA_FORWARD; + MULADD(at[45], at[127]); MULADD(at[46], at[126]); MULADD(at[47], at[125]); MULADD(at[48], at[124]); MULADD(at[49], at[123]); MULADD(at[50], at[122]); MULADD(at[51], at[121]); MULADD(at[52], at[120]); MULADD(at[53], at[119]); MULADD(at[54], at[118]); MULADD(at[55], at[117]); MULADD(at[56], at[116]); MULADD(at[57], at[115]); MULADD(at[58], at[114]); MULADD(at[59], at[113]); MULADD(at[60], at[112]); MULADD(at[61], at[111]); MULADD(at[62], at[110]); MULADD(at[63], at[109]); + COMBA_STORE(C->dp[108]); + /* 109 */ + COMBA_FORWARD; + MULADD(at[46], at[127]); MULADD(at[47], at[126]); MULADD(at[48], at[125]); MULADD(at[49], at[124]); MULADD(at[50], at[123]); MULADD(at[51], at[122]); MULADD(at[52], at[121]); MULADD(at[53], at[120]); MULADD(at[54], at[119]); MULADD(at[55], at[118]); MULADD(at[56], at[117]); MULADD(at[57], at[116]); MULADD(at[58], at[115]); MULADD(at[59], at[114]); MULADD(at[60], at[113]); MULADD(at[61], at[112]); MULADD(at[62], at[111]); MULADD(at[63], at[110]); + COMBA_STORE(C->dp[109]); + /* 110 */ + COMBA_FORWARD; + MULADD(at[47], at[127]); MULADD(at[48], at[126]); MULADD(at[49], at[125]); MULADD(at[50], at[124]); MULADD(at[51], at[123]); MULADD(at[52], at[122]); MULADD(at[53], at[121]); MULADD(at[54], at[120]); MULADD(at[55], at[119]); MULADD(at[56], at[118]); MULADD(at[57], at[117]); MULADD(at[58], at[116]); MULADD(at[59], at[115]); MULADD(at[60], at[114]); MULADD(at[61], at[113]); MULADD(at[62], at[112]); MULADD(at[63], at[111]); + COMBA_STORE(C->dp[110]); + /* 111 */ + COMBA_FORWARD; + MULADD(at[48], at[127]); MULADD(at[49], at[126]); MULADD(at[50], at[125]); MULADD(at[51], at[124]); MULADD(at[52], at[123]); MULADD(at[53], at[122]); MULADD(at[54], at[121]); MULADD(at[55], at[120]); MULADD(at[56], at[119]); MULADD(at[57], at[118]); MULADD(at[58], at[117]); MULADD(at[59], at[116]); MULADD(at[60], at[115]); MULADD(at[61], at[114]); MULADD(at[62], at[113]); MULADD(at[63], at[112]); + COMBA_STORE(C->dp[111]); + /* 112 */ + COMBA_FORWARD; + MULADD(at[49], at[127]); MULADD(at[50], at[126]); MULADD(at[51], at[125]); MULADD(at[52], at[124]); MULADD(at[53], at[123]); MULADD(at[54], at[122]); MULADD(at[55], at[121]); MULADD(at[56], at[120]); MULADD(at[57], at[119]); MULADD(at[58], at[118]); MULADD(at[59], at[117]); MULADD(at[60], at[116]); MULADD(at[61], at[115]); MULADD(at[62], at[114]); MULADD(at[63], at[113]); + COMBA_STORE(C->dp[112]); + /* 113 */ + COMBA_FORWARD; + MULADD(at[50], at[127]); MULADD(at[51], at[126]); MULADD(at[52], at[125]); MULADD(at[53], at[124]); MULADD(at[54], at[123]); MULADD(at[55], at[122]); MULADD(at[56], at[121]); MULADD(at[57], at[120]); MULADD(at[58], at[119]); MULADD(at[59], at[118]); MULADD(at[60], at[117]); MULADD(at[61], at[116]); MULADD(at[62], at[115]); MULADD(at[63], at[114]); + COMBA_STORE(C->dp[113]); + /* 114 */ + COMBA_FORWARD; + MULADD(at[51], at[127]); MULADD(at[52], at[126]); MULADD(at[53], at[125]); MULADD(at[54], at[124]); MULADD(at[55], at[123]); MULADD(at[56], at[122]); MULADD(at[57], at[121]); MULADD(at[58], at[120]); MULADD(at[59], at[119]); MULADD(at[60], at[118]); MULADD(at[61], at[117]); MULADD(at[62], at[116]); MULADD(at[63], at[115]); + COMBA_STORE(C->dp[114]); + /* 115 */ + COMBA_FORWARD; + MULADD(at[52], at[127]); MULADD(at[53], at[126]); MULADD(at[54], at[125]); MULADD(at[55], at[124]); MULADD(at[56], at[123]); MULADD(at[57], at[122]); MULADD(at[58], at[121]); MULADD(at[59], at[120]); MULADD(at[60], at[119]); MULADD(at[61], at[118]); MULADD(at[62], at[117]); MULADD(at[63], at[116]); + COMBA_STORE(C->dp[115]); + /* 116 */ + COMBA_FORWARD; + MULADD(at[53], at[127]); MULADD(at[54], at[126]); MULADD(at[55], at[125]); MULADD(at[56], at[124]); MULADD(at[57], at[123]); MULADD(at[58], at[122]); MULADD(at[59], at[121]); MULADD(at[60], at[120]); MULADD(at[61], at[119]); MULADD(at[62], at[118]); MULADD(at[63], at[117]); + COMBA_STORE(C->dp[116]); + /* 117 */ + COMBA_FORWARD; + MULADD(at[54], at[127]); MULADD(at[55], at[126]); MULADD(at[56], at[125]); MULADD(at[57], at[124]); MULADD(at[58], at[123]); MULADD(at[59], at[122]); MULADD(at[60], at[121]); MULADD(at[61], at[120]); MULADD(at[62], at[119]); MULADD(at[63], at[118]); + COMBA_STORE(C->dp[117]); + /* 118 */ + COMBA_FORWARD; + MULADD(at[55], at[127]); MULADD(at[56], at[126]); MULADD(at[57], at[125]); MULADD(at[58], at[124]); MULADD(at[59], at[123]); MULADD(at[60], at[122]); MULADD(at[61], at[121]); MULADD(at[62], at[120]); MULADD(at[63], at[119]); + COMBA_STORE(C->dp[118]); + /* 119 */ + COMBA_FORWARD; + MULADD(at[56], at[127]); MULADD(at[57], at[126]); MULADD(at[58], at[125]); MULADD(at[59], at[124]); MULADD(at[60], at[123]); MULADD(at[61], at[122]); MULADD(at[62], at[121]); MULADD(at[63], at[120]); + COMBA_STORE(C->dp[119]); + /* 120 */ + COMBA_FORWARD; + MULADD(at[57], at[127]); MULADD(at[58], at[126]); MULADD(at[59], at[125]); MULADD(at[60], at[124]); MULADD(at[61], at[123]); MULADD(at[62], at[122]); MULADD(at[63], at[121]); + COMBA_STORE(C->dp[120]); + /* 121 */ + COMBA_FORWARD; + MULADD(at[58], at[127]); MULADD(at[59], at[126]); MULADD(at[60], at[125]); MULADD(at[61], at[124]); MULADD(at[62], at[123]); MULADD(at[63], at[122]); + COMBA_STORE(C->dp[121]); + /* 122 */ + COMBA_FORWARD; + MULADD(at[59], at[127]); MULADD(at[60], at[126]); MULADD(at[61], at[125]); MULADD(at[62], at[124]); MULADD(at[63], at[123]); + COMBA_STORE(C->dp[122]); + /* 123 */ + COMBA_FORWARD; + MULADD(at[60], at[127]); MULADD(at[61], at[126]); MULADD(at[62], at[125]); MULADD(at[63], at[124]); + COMBA_STORE(C->dp[123]); + /* 124 */ + COMBA_FORWARD; + MULADD(at[61], at[127]); MULADD(at[62], at[126]); MULADD(at[63], at[125]); + COMBA_STORE(C->dp[124]); + /* 125 */ + COMBA_FORWARD; + MULADD(at[62], at[127]); MULADD(at[63], at[126]); + COMBA_STORE(C->dp[125]); + /* 126 */ + COMBA_FORWARD; + MULADD(at[63], at[127]); + COMBA_STORE(C->dp[126]); + COMBA_STORE2(C->dp[127]); + C->used = 128; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; +} + +void fp_mul_comba48(fp_int *A, fp_int *B, fp_int *C) +{ + fp_digit c0, c1, c2, at[96]; + + memcpy(at, A->dp, 48 * sizeof(fp_digit)); + memcpy(at+48, B->dp, 48 * sizeof(fp_digit)); + COMBA_START; + + COMBA_CLEAR; + /* 0 */ + MULADD(at[0], at[48]); + COMBA_STORE(C->dp[0]); + /* 1 */ + COMBA_FORWARD; + MULADD(at[0], at[49]); MULADD(at[1], at[48]); + COMBA_STORE(C->dp[1]); + /* 2 */ + COMBA_FORWARD; + MULADD(at[0], at[50]); MULADD(at[1], at[49]); MULADD(at[2], at[48]); + COMBA_STORE(C->dp[2]); + /* 3 */ + COMBA_FORWARD; + MULADD(at[0], at[51]); MULADD(at[1], at[50]); MULADD(at[2], at[49]); MULADD(at[3], at[48]); + COMBA_STORE(C->dp[3]); + /* 4 */ + 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]); + COMBA_STORE(C->dp[4]); + /* 5 */ + 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]); + COMBA_STORE(C->dp[5]); + /* 6 */ + 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]); + COMBA_STORE(C->dp[6]); + /* 7 */ + 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]); + COMBA_STORE(C->dp[7]); + /* 8 */ + 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]); + COMBA_STORE(C->dp[8]); + /* 9 */ + 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]); + COMBA_STORE(C->dp[9]); + /* 10 */ + 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]); + COMBA_STORE(C->dp[10]); + /* 11 */ + 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]); + COMBA_STORE(C->dp[11]); + /* 12 */ + 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]); + COMBA_STORE(C->dp[12]); + /* 13 */ + 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]); + COMBA_STORE(C->dp[13]); + /* 14 */ + 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]); + COMBA_STORE(C->dp[14]); + /* 15 */ + 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]); + COMBA_STORE(C->dp[15]); + /* 16 */ + COMBA_FORWARD; + MULADD(at[0], at[64]); 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]); + COMBA_STORE(C->dp[16]); + /* 17 */ + COMBA_FORWARD; + MULADD(at[0], at[65]); MULADD(at[1], at[64]); 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]); + COMBA_STORE(C->dp[17]); + /* 18 */ + COMBA_FORWARD; + MULADD(at[0], at[66]); MULADD(at[1], at[65]); MULADD(at[2], at[64]); 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]); + COMBA_STORE(C->dp[18]); + /* 19 */ + COMBA_FORWARD; + MULADD(at[0], at[67]); MULADD(at[1], at[66]); MULADD(at[2], at[65]); MULADD(at[3], at[64]); 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]); + COMBA_STORE(C->dp[19]); + /* 20 */ + COMBA_FORWARD; + MULADD(at[0], at[68]); MULADD(at[1], at[67]); MULADD(at[2], at[66]); MULADD(at[3], at[65]); MULADD(at[4], at[64]); 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]); + COMBA_STORE(C->dp[20]); + /* 21 */ + COMBA_FORWARD; + MULADD(at[0], at[69]); MULADD(at[1], at[68]); MULADD(at[2], at[67]); MULADD(at[3], at[66]); MULADD(at[4], at[65]); MULADD(at[5], at[64]); 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]); + COMBA_STORE(C->dp[21]); + /* 22 */ + COMBA_FORWARD; + MULADD(at[0], at[70]); MULADD(at[1], at[69]); MULADD(at[2], at[68]); MULADD(at[3], at[67]); MULADD(at[4], at[66]); MULADD(at[5], at[65]); MULADD(at[6], at[64]); 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]); + COMBA_STORE(C->dp[22]); + /* 23 */ + COMBA_FORWARD; + MULADD(at[0], at[71]); MULADD(at[1], at[70]); MULADD(at[2], at[69]); MULADD(at[3], at[68]); MULADD(at[4], at[67]); MULADD(at[5], at[66]); MULADD(at[6], at[65]); MULADD(at[7], at[64]); 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]); + COMBA_STORE(C->dp[23]); + /* 24 */ + COMBA_FORWARD; + MULADD(at[0], at[72]); MULADD(at[1], at[71]); MULADD(at[2], at[70]); MULADD(at[3], at[69]); MULADD(at[4], at[68]); MULADD(at[5], at[67]); MULADD(at[6], at[66]); MULADD(at[7], at[65]); MULADD(at[8], at[64]); 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]); + COMBA_STORE(C->dp[24]); + /* 25 */ + COMBA_FORWARD; + MULADD(at[0], at[73]); MULADD(at[1], at[72]); MULADD(at[2], at[71]); MULADD(at[3], at[70]); MULADD(at[4], at[69]); MULADD(at[5], at[68]); MULADD(at[6], at[67]); MULADD(at[7], at[66]); MULADD(at[8], at[65]); MULADD(at[9], at[64]); 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]); + COMBA_STORE(C->dp[25]); + /* 26 */ + COMBA_FORWARD; + MULADD(at[0], at[74]); MULADD(at[1], at[73]); MULADD(at[2], at[72]); MULADD(at[3], at[71]); MULADD(at[4], at[70]); MULADD(at[5], at[69]); MULADD(at[6], at[68]); MULADD(at[7], at[67]); MULADD(at[8], at[66]); MULADD(at[9], at[65]); MULADD(at[10], at[64]); 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]); + COMBA_STORE(C->dp[26]); + /* 27 */ + COMBA_FORWARD; + MULADD(at[0], at[75]); MULADD(at[1], at[74]); MULADD(at[2], at[73]); MULADD(at[3], at[72]); MULADD(at[4], at[71]); MULADD(at[5], at[70]); MULADD(at[6], at[69]); MULADD(at[7], at[68]); MULADD(at[8], at[67]); MULADD(at[9], at[66]); MULADD(at[10], at[65]); MULADD(at[11], at[64]); 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]); + COMBA_STORE(C->dp[27]); + /* 28 */ + COMBA_FORWARD; + MULADD(at[0], at[76]); MULADD(at[1], at[75]); MULADD(at[2], at[74]); MULADD(at[3], at[73]); MULADD(at[4], at[72]); MULADD(at[5], at[71]); MULADD(at[6], at[70]); MULADD(at[7], at[69]); MULADD(at[8], at[68]); MULADD(at[9], at[67]); MULADD(at[10], at[66]); MULADD(at[11], at[65]); MULADD(at[12], at[64]); 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]); + COMBA_STORE(C->dp[28]); + /* 29 */ + COMBA_FORWARD; + MULADD(at[0], at[77]); MULADD(at[1], at[76]); MULADD(at[2], at[75]); MULADD(at[3], at[74]); MULADD(at[4], at[73]); MULADD(at[5], at[72]); MULADD(at[6], at[71]); MULADD(at[7], at[70]); MULADD(at[8], at[69]); MULADD(at[9], at[68]); MULADD(at[10], at[67]); MULADD(at[11], at[66]); MULADD(at[12], at[65]); MULADD(at[13], at[64]); 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]); + COMBA_STORE(C->dp[29]); + /* 30 */ + COMBA_FORWARD; + MULADD(at[0], at[78]); MULADD(at[1], at[77]); MULADD(at[2], at[76]); MULADD(at[3], at[75]); MULADD(at[4], at[74]); MULADD(at[5], at[73]); MULADD(at[6], at[72]); MULADD(at[7], at[71]); MULADD(at[8], at[70]); MULADD(at[9], at[69]); MULADD(at[10], at[68]); MULADD(at[11], at[67]); MULADD(at[12], at[66]); MULADD(at[13], at[65]); MULADD(at[14], at[64]); 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]); + COMBA_STORE(C->dp[30]); + /* 31 */ + COMBA_FORWARD; + MULADD(at[0], at[79]); MULADD(at[1], at[78]); MULADD(at[2], at[77]); MULADD(at[3], at[76]); MULADD(at[4], at[75]); MULADD(at[5], at[74]); MULADD(at[6], at[73]); MULADD(at[7], at[72]); MULADD(at[8], at[71]); MULADD(at[9], at[70]); MULADD(at[10], at[69]); MULADD(at[11], at[68]); MULADD(at[12], at[67]); MULADD(at[13], at[66]); MULADD(at[14], at[65]); MULADD(at[15], at[64]); 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[31]); + /* 32 */ + COMBA_FORWARD; + MULADD(at[0], at[80]); MULADD(at[1], at[79]); MULADD(at[2], at[78]); MULADD(at[3], at[77]); MULADD(at[4], at[76]); MULADD(at[5], at[75]); MULADD(at[6], at[74]); MULADD(at[7], at[73]); MULADD(at[8], at[72]); MULADD(at[9], at[71]); MULADD(at[10], at[70]); MULADD(at[11], at[69]); MULADD(at[12], at[68]); MULADD(at[13], at[67]); MULADD(at[14], at[66]); MULADD(at[15], at[65]); MULADD(at[16], at[64]); 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]); MULADD(at[32], at[48]); + COMBA_STORE(C->dp[32]); + /* 33 */ + COMBA_FORWARD; + MULADD(at[0], at[81]); MULADD(at[1], at[80]); MULADD(at[2], at[79]); MULADD(at[3], at[78]); MULADD(at[4], at[77]); MULADD(at[5], at[76]); MULADD(at[6], at[75]); MULADD(at[7], at[74]); MULADD(at[8], at[73]); MULADD(at[9], at[72]); MULADD(at[10], at[71]); MULADD(at[11], at[70]); MULADD(at[12], at[69]); MULADD(at[13], at[68]); MULADD(at[14], at[67]); MULADD(at[15], at[66]); MULADD(at[16], at[65]); MULADD(at[17], at[64]); 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]); MULADD(at[32], at[49]); MULADD(at[33], at[48]); + COMBA_STORE(C->dp[33]); + /* 34 */ + COMBA_FORWARD; + MULADD(at[0], at[82]); MULADD(at[1], at[81]); MULADD(at[2], at[80]); MULADD(at[3], at[79]); MULADD(at[4], at[78]); MULADD(at[5], at[77]); MULADD(at[6], at[76]); MULADD(at[7], at[75]); MULADD(at[8], at[74]); MULADD(at[9], at[73]); MULADD(at[10], at[72]); MULADD(at[11], at[71]); MULADD(at[12], at[70]); MULADD(at[13], at[69]); MULADD(at[14], at[68]); MULADD(at[15], at[67]); MULADD(at[16], at[66]); MULADD(at[17], at[65]); MULADD(at[18], at[64]); 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]); MULADD(at[32], at[50]); MULADD(at[33], at[49]); MULADD(at[34], at[48]); + COMBA_STORE(C->dp[34]); + /* 35 */ + COMBA_FORWARD; + MULADD(at[0], at[83]); MULADD(at[1], at[82]); MULADD(at[2], at[81]); MULADD(at[3], at[80]); MULADD(at[4], at[79]); MULADD(at[5], at[78]); MULADD(at[6], at[77]); MULADD(at[7], at[76]); MULADD(at[8], at[75]); MULADD(at[9], at[74]); MULADD(at[10], at[73]); MULADD(at[11], at[72]); MULADD(at[12], at[71]); MULADD(at[13], at[70]); MULADD(at[14], at[69]); MULADD(at[15], at[68]); MULADD(at[16], at[67]); MULADD(at[17], at[66]); MULADD(at[18], at[65]); MULADD(at[19], at[64]); 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]); MULADD(at[32], at[51]); MULADD(at[33], at[50]); MULADD(at[34], at[49]); MULADD(at[35], at[48]); + COMBA_STORE(C->dp[35]); + /* 36 */ + COMBA_FORWARD; + MULADD(at[0], at[84]); MULADD(at[1], at[83]); MULADD(at[2], at[82]); MULADD(at[3], at[81]); MULADD(at[4], at[80]); MULADD(at[5], at[79]); MULADD(at[6], at[78]); MULADD(at[7], at[77]); MULADD(at[8], at[76]); MULADD(at[9], at[75]); MULADD(at[10], at[74]); MULADD(at[11], at[73]); MULADD(at[12], at[72]); MULADD(at[13], at[71]); MULADD(at[14], at[70]); MULADD(at[15], at[69]); MULADD(at[16], at[68]); MULADD(at[17], at[67]); MULADD(at[18], at[66]); MULADD(at[19], at[65]); MULADD(at[20], at[64]); 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]); MULADD(at[32], at[52]); MULADD(at[33], at[51]); MULADD(at[34], at[50]); MULADD(at[35], at[49]); MULADD(at[36], at[48]); + COMBA_STORE(C->dp[36]); + /* 37 */ + COMBA_FORWARD; + MULADD(at[0], at[85]); MULADD(at[1], at[84]); MULADD(at[2], at[83]); MULADD(at[3], at[82]); MULADD(at[4], at[81]); MULADD(at[5], at[80]); MULADD(at[6], at[79]); MULADD(at[7], at[78]); MULADD(at[8], at[77]); MULADD(at[9], at[76]); MULADD(at[10], at[75]); MULADD(at[11], at[74]); MULADD(at[12], at[73]); MULADD(at[13], at[72]); MULADD(at[14], at[71]); MULADD(at[15], at[70]); MULADD(at[16], at[69]); MULADD(at[17], at[68]); MULADD(at[18], at[67]); MULADD(at[19], at[66]); MULADD(at[20], at[65]); MULADD(at[21], at[64]); 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]); MULADD(at[32], at[53]); MULADD(at[33], at[52]); MULADD(at[34], at[51]); MULADD(at[35], at[50]); MULADD(at[36], at[49]); MULADD(at[37], at[48]); + COMBA_STORE(C->dp[37]); + /* 38 */ + COMBA_FORWARD; + MULADD(at[0], at[86]); MULADD(at[1], at[85]); MULADD(at[2], at[84]); MULADD(at[3], at[83]); MULADD(at[4], at[82]); MULADD(at[5], at[81]); MULADD(at[6], at[80]); MULADD(at[7], at[79]); MULADD(at[8], at[78]); MULADD(at[9], at[77]); MULADD(at[10], at[76]); MULADD(at[11], at[75]); MULADD(at[12], at[74]); MULADD(at[13], at[73]); MULADD(at[14], at[72]); MULADD(at[15], at[71]); MULADD(at[16], at[70]); MULADD(at[17], at[69]); MULADD(at[18], at[68]); MULADD(at[19], at[67]); MULADD(at[20], at[66]); MULADD(at[21], at[65]); MULADD(at[22], at[64]); 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]); MULADD(at[32], at[54]); MULADD(at[33], at[53]); MULADD(at[34], at[52]); MULADD(at[35], at[51]); MULADD(at[36], at[50]); MULADD(at[37], at[49]); MULADD(at[38], at[48]); + COMBA_STORE(C->dp[38]); + /* 39 */ + COMBA_FORWARD; + MULADD(at[0], at[87]); MULADD(at[1], at[86]); MULADD(at[2], at[85]); MULADD(at[3], at[84]); MULADD(at[4], at[83]); MULADD(at[5], at[82]); MULADD(at[6], at[81]); MULADD(at[7], at[80]); MULADD(at[8], at[79]); MULADD(at[9], at[78]); MULADD(at[10], at[77]); MULADD(at[11], at[76]); MULADD(at[12], at[75]); MULADD(at[13], at[74]); MULADD(at[14], at[73]); MULADD(at[15], at[72]); MULADD(at[16], at[71]); MULADD(at[17], at[70]); MULADD(at[18], at[69]); MULADD(at[19], at[68]); MULADD(at[20], at[67]); MULADD(at[21], at[66]); MULADD(at[22], at[65]); MULADD(at[23], at[64]); 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]); MULADD(at[32], at[55]); MULADD(at[33], at[54]); MULADD(at[34], at[53]); MULADD(at[35], at[52]); MULADD(at[36], at[51]); MULADD(at[37], at[50]); MULADD(at[38], at[49]); MULADD(at[39], at[48]); + COMBA_STORE(C->dp[39]); + /* 40 */ + COMBA_FORWARD; + MULADD(at[0], at[88]); MULADD(at[1], at[87]); MULADD(at[2], at[86]); MULADD(at[3], at[85]); MULADD(at[4], at[84]); MULADD(at[5], at[83]); MULADD(at[6], at[82]); MULADD(at[7], at[81]); MULADD(at[8], at[80]); MULADD(at[9], at[79]); MULADD(at[10], at[78]); MULADD(at[11], at[77]); MULADD(at[12], at[76]); MULADD(at[13], at[75]); MULADD(at[14], at[74]); MULADD(at[15], at[73]); MULADD(at[16], at[72]); MULADD(at[17], at[71]); MULADD(at[18], at[70]); MULADD(at[19], at[69]); MULADD(at[20], at[68]); MULADD(at[21], at[67]); MULADD(at[22], at[66]); MULADD(at[23], at[65]); MULADD(at[24], at[64]); 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]); MULADD(at[32], at[56]); MULADD(at[33], at[55]); MULADD(at[34], at[54]); MULADD(at[35], at[53]); MULADD(at[36], at[52]); MULADD(at[37], at[51]); MULADD(at[38], at[50]); MULADD(at[39], at[49]); MULADD(at[40], at[48]); + COMBA_STORE(C->dp[40]); + /* 41 */ + COMBA_FORWARD; + MULADD(at[0], at[89]); MULADD(at[1], at[88]); MULADD(at[2], at[87]); MULADD(at[3], at[86]); MULADD(at[4], at[85]); MULADD(at[5], at[84]); MULADD(at[6], at[83]); MULADD(at[7], at[82]); MULADD(at[8], at[81]); MULADD(at[9], at[80]); MULADD(at[10], at[79]); MULADD(at[11], at[78]); MULADD(at[12], at[77]); MULADD(at[13], at[76]); MULADD(at[14], at[75]); MULADD(at[15], at[74]); MULADD(at[16], at[73]); MULADD(at[17], at[72]); MULADD(at[18], at[71]); MULADD(at[19], at[70]); MULADD(at[20], at[69]); MULADD(at[21], at[68]); MULADD(at[22], at[67]); MULADD(at[23], at[66]); MULADD(at[24], at[65]); MULADD(at[25], at[64]); 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]); MULADD(at[32], at[57]); MULADD(at[33], at[56]); MULADD(at[34], at[55]); MULADD(at[35], at[54]); MULADD(at[36], at[53]); MULADD(at[37], at[52]); MULADD(at[38], at[51]); MULADD(at[39], at[50]); MULADD(at[40], at[49]); MULADD(at[41], at[48]); + COMBA_STORE(C->dp[41]); + /* 42 */ + COMBA_FORWARD; + MULADD(at[0], at[90]); MULADD(at[1], at[89]); MULADD(at[2], at[88]); MULADD(at[3], at[87]); MULADD(at[4], at[86]); MULADD(at[5], at[85]); MULADD(at[6], at[84]); MULADD(at[7], at[83]); MULADD(at[8], at[82]); MULADD(at[9], at[81]); MULADD(at[10], at[80]); MULADD(at[11], at[79]); MULADD(at[12], at[78]); MULADD(at[13], at[77]); MULADD(at[14], at[76]); MULADD(at[15], at[75]); MULADD(at[16], at[74]); MULADD(at[17], at[73]); MULADD(at[18], at[72]); MULADD(at[19], at[71]); MULADD(at[20], at[70]); MULADD(at[21], at[69]); MULADD(at[22], at[68]); MULADD(at[23], at[67]); MULADD(at[24], at[66]); MULADD(at[25], at[65]); MULADD(at[26], at[64]); 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]); MULADD(at[32], at[58]); MULADD(at[33], at[57]); MULADD(at[34], at[56]); MULADD(at[35], at[55]); MULADD(at[36], at[54]); MULADD(at[37], at[53]); MULADD(at[38], at[52]); MULADD(at[39], at[51]); MULADD(at[40], at[50]); MULADD(at[41], at[49]); MULADD(at[42], at[48]); + COMBA_STORE(C->dp[42]); + /* 43 */ + COMBA_FORWARD; + MULADD(at[0], at[91]); MULADD(at[1], at[90]); MULADD(at[2], at[89]); MULADD(at[3], at[88]); MULADD(at[4], at[87]); MULADD(at[5], at[86]); MULADD(at[6], at[85]); MULADD(at[7], at[84]); MULADD(at[8], at[83]); MULADD(at[9], at[82]); MULADD(at[10], at[81]); MULADD(at[11], at[80]); MULADD(at[12], at[79]); MULADD(at[13], at[78]); MULADD(at[14], at[77]); MULADD(at[15], at[76]); MULADD(at[16], at[75]); MULADD(at[17], at[74]); MULADD(at[18], at[73]); MULADD(at[19], at[72]); MULADD(at[20], at[71]); MULADD(at[21], at[70]); MULADD(at[22], at[69]); MULADD(at[23], at[68]); MULADD(at[24], at[67]); MULADD(at[25], at[66]); MULADD(at[26], at[65]); MULADD(at[27], at[64]); MULADD(at[28], at[63]); MULADD(at[29], at[62]); MULADD(at[30], at[61]); MULADD(at[31], at[60]); MULADD(at[32], at[59]); MULADD(at[33], at[58]); MULADD(at[34], at[57]); MULADD(at[35], at[56]); MULADD(at[36], at[55]); MULADD(at[37], at[54]); MULADD(at[38], at[53]); MULADD(at[39], at[52]); MULADD(at[40], at[51]); MULADD(at[41], at[50]); MULADD(at[42], at[49]); MULADD(at[43], at[48]); + COMBA_STORE(C->dp[43]); + /* 44 */ + COMBA_FORWARD; + MULADD(at[0], at[92]); MULADD(at[1], at[91]); MULADD(at[2], at[90]); MULADD(at[3], at[89]); MULADD(at[4], at[88]); MULADD(at[5], at[87]); MULADD(at[6], at[86]); MULADD(at[7], at[85]); MULADD(at[8], at[84]); MULADD(at[9], at[83]); MULADD(at[10], at[82]); MULADD(at[11], at[81]); MULADD(at[12], at[80]); MULADD(at[13], at[79]); MULADD(at[14], at[78]); MULADD(at[15], at[77]); MULADD(at[16], at[76]); MULADD(at[17], at[75]); MULADD(at[18], at[74]); MULADD(at[19], at[73]); MULADD(at[20], at[72]); MULADD(at[21], at[71]); MULADD(at[22], at[70]); MULADD(at[23], at[69]); MULADD(at[24], at[68]); MULADD(at[25], at[67]); MULADD(at[26], at[66]); MULADD(at[27], at[65]); MULADD(at[28], at[64]); MULADD(at[29], at[63]); MULADD(at[30], at[62]); MULADD(at[31], at[61]); MULADD(at[32], at[60]); MULADD(at[33], at[59]); MULADD(at[34], at[58]); MULADD(at[35], at[57]); MULADD(at[36], at[56]); MULADD(at[37], at[55]); MULADD(at[38], at[54]); MULADD(at[39], at[53]); MULADD(at[40], at[52]); MULADD(at[41], at[51]); MULADD(at[42], at[50]); MULADD(at[43], at[49]); MULADD(at[44], at[48]); + COMBA_STORE(C->dp[44]); + /* 45 */ + COMBA_FORWARD; + MULADD(at[0], at[93]); MULADD(at[1], at[92]); MULADD(at[2], at[91]); MULADD(at[3], at[90]); MULADD(at[4], at[89]); MULADD(at[5], at[88]); MULADD(at[6], at[87]); MULADD(at[7], at[86]); MULADD(at[8], at[85]); MULADD(at[9], at[84]); MULADD(at[10], at[83]); MULADD(at[11], at[82]); MULADD(at[12], at[81]); MULADD(at[13], at[80]); MULADD(at[14], at[79]); MULADD(at[15], at[78]); MULADD(at[16], at[77]); MULADD(at[17], at[76]); MULADD(at[18], at[75]); MULADD(at[19], at[74]); MULADD(at[20], at[73]); MULADD(at[21], at[72]); MULADD(at[22], at[71]); MULADD(at[23], at[70]); MULADD(at[24], at[69]); MULADD(at[25], at[68]); MULADD(at[26], at[67]); MULADD(at[27], at[66]); MULADD(at[28], at[65]); MULADD(at[29], at[64]); MULADD(at[30], at[63]); MULADD(at[31], at[62]); MULADD(at[32], at[61]); MULADD(at[33], at[60]); MULADD(at[34], at[59]); MULADD(at[35], at[58]); MULADD(at[36], at[57]); MULADD(at[37], at[56]); MULADD(at[38], at[55]); MULADD(at[39], at[54]); MULADD(at[40], at[53]); MULADD(at[41], at[52]); MULADD(at[42], at[51]); MULADD(at[43], at[50]); MULADD(at[44], at[49]); MULADD(at[45], at[48]); + COMBA_STORE(C->dp[45]); + /* 46 */ + COMBA_FORWARD; + MULADD(at[0], at[94]); MULADD(at[1], at[93]); MULADD(at[2], at[92]); MULADD(at[3], at[91]); MULADD(at[4], at[90]); MULADD(at[5], at[89]); MULADD(at[6], at[88]); MULADD(at[7], at[87]); MULADD(at[8], at[86]); MULADD(at[9], at[85]); MULADD(at[10], at[84]); MULADD(at[11], at[83]); MULADD(at[12], at[82]); MULADD(at[13], at[81]); MULADD(at[14], at[80]); MULADD(at[15], at[79]); MULADD(at[16], at[78]); MULADD(at[17], at[77]); MULADD(at[18], at[76]); MULADD(at[19], at[75]); MULADD(at[20], at[74]); MULADD(at[21], at[73]); MULADD(at[22], at[72]); MULADD(at[23], at[71]); MULADD(at[24], at[70]); MULADD(at[25], at[69]); MULADD(at[26], at[68]); MULADD(at[27], at[67]); MULADD(at[28], at[66]); MULADD(at[29], at[65]); MULADD(at[30], at[64]); MULADD(at[31], at[63]); MULADD(at[32], at[62]); MULADD(at[33], at[61]); MULADD(at[34], at[60]); MULADD(at[35], at[59]); MULADD(at[36], at[58]); MULADD(at[37], at[57]); MULADD(at[38], at[56]); MULADD(at[39], at[55]); MULADD(at[40], at[54]); MULADD(at[41], at[53]); MULADD(at[42], at[52]); MULADD(at[43], at[51]); MULADD(at[44], at[50]); MULADD(at[45], at[49]); MULADD(at[46], at[48]); + COMBA_STORE(C->dp[46]); + /* 47 */ + COMBA_FORWARD; + MULADD(at[0], at[95]); MULADD(at[1], at[94]); MULADD(at[2], at[93]); MULADD(at[3], at[92]); MULADD(at[4], at[91]); MULADD(at[5], at[90]); MULADD(at[6], at[89]); MULADD(at[7], at[88]); MULADD(at[8], at[87]); MULADD(at[9], at[86]); MULADD(at[10], at[85]); MULADD(at[11], at[84]); MULADD(at[12], at[83]); MULADD(at[13], at[82]); MULADD(at[14], at[81]); MULADD(at[15], at[80]); MULADD(at[16], at[79]); MULADD(at[17], at[78]); MULADD(at[18], at[77]); MULADD(at[19], at[76]); MULADD(at[20], at[75]); MULADD(at[21], at[74]); MULADD(at[22], at[73]); MULADD(at[23], at[72]); MULADD(at[24], at[71]); MULADD(at[25], at[70]); MULADD(at[26], at[69]); MULADD(at[27], at[68]); MULADD(at[28], at[67]); MULADD(at[29], at[66]); MULADD(at[30], at[65]); MULADD(at[31], at[64]); MULADD(at[32], at[63]); MULADD(at[33], at[62]); MULADD(at[34], at[61]); MULADD(at[35], at[60]); MULADD(at[36], at[59]); MULADD(at[37], at[58]); MULADD(at[38], at[57]); MULADD(at[39], at[56]); MULADD(at[40], at[55]); MULADD(at[41], at[54]); MULADD(at[42], at[53]); MULADD(at[43], at[52]); MULADD(at[44], at[51]); MULADD(at[45], at[50]); MULADD(at[46], at[49]); MULADD(at[47], at[48]); + COMBA_STORE(C->dp[47]); + /* 48 */ + COMBA_FORWARD; + MULADD(at[1], at[95]); MULADD(at[2], at[94]); MULADD(at[3], at[93]); MULADD(at[4], at[92]); MULADD(at[5], at[91]); MULADD(at[6], at[90]); MULADD(at[7], at[89]); MULADD(at[8], at[88]); MULADD(at[9], at[87]); MULADD(at[10], at[86]); MULADD(at[11], at[85]); MULADD(at[12], at[84]); MULADD(at[13], at[83]); MULADD(at[14], at[82]); MULADD(at[15], at[81]); MULADD(at[16], at[80]); MULADD(at[17], at[79]); MULADD(at[18], at[78]); MULADD(at[19], at[77]); MULADD(at[20], at[76]); MULADD(at[21], at[75]); MULADD(at[22], at[74]); MULADD(at[23], at[73]); MULADD(at[24], at[72]); MULADD(at[25], at[71]); MULADD(at[26], at[70]); MULADD(at[27], at[69]); MULADD(at[28], at[68]); MULADD(at[29], at[67]); MULADD(at[30], at[66]); MULADD(at[31], at[65]); MULADD(at[32], at[64]); MULADD(at[33], at[63]); MULADD(at[34], at[62]); MULADD(at[35], at[61]); MULADD(at[36], at[60]); MULADD(at[37], at[59]); MULADD(at[38], at[58]); MULADD(at[39], at[57]); MULADD(at[40], at[56]); MULADD(at[41], at[55]); MULADD(at[42], at[54]); MULADD(at[43], at[53]); MULADD(at[44], at[52]); MULADD(at[45], at[51]); MULADD(at[46], at[50]); MULADD(at[47], at[49]); + COMBA_STORE(C->dp[48]); + /* 49 */ + COMBA_FORWARD; + MULADD(at[2], at[95]); MULADD(at[3], at[94]); MULADD(at[4], at[93]); MULADD(at[5], at[92]); MULADD(at[6], at[91]); MULADD(at[7], at[90]); MULADD(at[8], at[89]); MULADD(at[9], at[88]); MULADD(at[10], at[87]); MULADD(at[11], at[86]); MULADD(at[12], at[85]); MULADD(at[13], at[84]); MULADD(at[14], at[83]); MULADD(at[15], at[82]); MULADD(at[16], at[81]); MULADD(at[17], at[80]); MULADD(at[18], at[79]); MULADD(at[19], at[78]); MULADD(at[20], at[77]); MULADD(at[21], at[76]); MULADD(at[22], at[75]); MULADD(at[23], at[74]); MULADD(at[24], at[73]); MULADD(at[25], at[72]); MULADD(at[26], at[71]); MULADD(at[27], at[70]); MULADD(at[28], at[69]); MULADD(at[29], at[68]); MULADD(at[30], at[67]); MULADD(at[31], at[66]); MULADD(at[32], at[65]); MULADD(at[33], at[64]); MULADD(at[34], at[63]); MULADD(at[35], at[62]); MULADD(at[36], at[61]); MULADD(at[37], at[60]); MULADD(at[38], at[59]); MULADD(at[39], at[58]); MULADD(at[40], at[57]); MULADD(at[41], at[56]); MULADD(at[42], at[55]); MULADD(at[43], at[54]); MULADD(at[44], at[53]); MULADD(at[45], at[52]); MULADD(at[46], at[51]); MULADD(at[47], at[50]); + COMBA_STORE(C->dp[49]); + /* 50 */ + COMBA_FORWARD; + MULADD(at[3], at[95]); MULADD(at[4], at[94]); MULADD(at[5], at[93]); MULADD(at[6], at[92]); MULADD(at[7], at[91]); MULADD(at[8], at[90]); MULADD(at[9], at[89]); MULADD(at[10], at[88]); MULADD(at[11], at[87]); MULADD(at[12], at[86]); MULADD(at[13], at[85]); MULADD(at[14], at[84]); MULADD(at[15], at[83]); MULADD(at[16], at[82]); MULADD(at[17], at[81]); MULADD(at[18], at[80]); MULADD(at[19], at[79]); MULADD(at[20], at[78]); MULADD(at[21], at[77]); MULADD(at[22], at[76]); MULADD(at[23], at[75]); MULADD(at[24], at[74]); MULADD(at[25], at[73]); MULADD(at[26], at[72]); MULADD(at[27], at[71]); MULADD(at[28], at[70]); MULADD(at[29], at[69]); MULADD(at[30], at[68]); MULADD(at[31], at[67]); MULADD(at[32], at[66]); MULADD(at[33], at[65]); MULADD(at[34], at[64]); MULADD(at[35], at[63]); MULADD(at[36], at[62]); MULADD(at[37], at[61]); MULADD(at[38], at[60]); MULADD(at[39], at[59]); MULADD(at[40], at[58]); MULADD(at[41], at[57]); MULADD(at[42], at[56]); MULADD(at[43], at[55]); MULADD(at[44], at[54]); MULADD(at[45], at[53]); MULADD(at[46], at[52]); MULADD(at[47], at[51]); + COMBA_STORE(C->dp[50]); + /* 51 */ + COMBA_FORWARD; + MULADD(at[4], at[95]); MULADD(at[5], at[94]); MULADD(at[6], at[93]); MULADD(at[7], at[92]); MULADD(at[8], at[91]); MULADD(at[9], at[90]); MULADD(at[10], at[89]); MULADD(at[11], at[88]); MULADD(at[12], at[87]); MULADD(at[13], at[86]); MULADD(at[14], at[85]); MULADD(at[15], at[84]); MULADD(at[16], at[83]); MULADD(at[17], at[82]); MULADD(at[18], at[81]); MULADD(at[19], at[80]); MULADD(at[20], at[79]); MULADD(at[21], at[78]); MULADD(at[22], at[77]); MULADD(at[23], at[76]); MULADD(at[24], at[75]); MULADD(at[25], at[74]); MULADD(at[26], at[73]); MULADD(at[27], at[72]); MULADD(at[28], at[71]); MULADD(at[29], at[70]); MULADD(at[30], at[69]); MULADD(at[31], at[68]); MULADD(at[32], at[67]); MULADD(at[33], at[66]); MULADD(at[34], at[65]); MULADD(at[35], at[64]); MULADD(at[36], at[63]); MULADD(at[37], at[62]); MULADD(at[38], at[61]); MULADD(at[39], at[60]); MULADD(at[40], at[59]); MULADD(at[41], at[58]); MULADD(at[42], at[57]); MULADD(at[43], at[56]); MULADD(at[44], at[55]); MULADD(at[45], at[54]); MULADD(at[46], at[53]); MULADD(at[47], at[52]); + COMBA_STORE(C->dp[51]); + /* 52 */ + COMBA_FORWARD; + MULADD(at[5], at[95]); MULADD(at[6], at[94]); MULADD(at[7], at[93]); MULADD(at[8], at[92]); MULADD(at[9], at[91]); MULADD(at[10], at[90]); MULADD(at[11], at[89]); MULADD(at[12], at[88]); MULADD(at[13], at[87]); MULADD(at[14], at[86]); MULADD(at[15], at[85]); MULADD(at[16], at[84]); MULADD(at[17], at[83]); MULADD(at[18], at[82]); MULADD(at[19], at[81]); MULADD(at[20], at[80]); MULADD(at[21], at[79]); MULADD(at[22], at[78]); MULADD(at[23], at[77]); MULADD(at[24], at[76]); MULADD(at[25], at[75]); MULADD(at[26], at[74]); MULADD(at[27], at[73]); MULADD(at[28], at[72]); MULADD(at[29], at[71]); MULADD(at[30], at[70]); MULADD(at[31], at[69]); MULADD(at[32], at[68]); MULADD(at[33], at[67]); MULADD(at[34], at[66]); MULADD(at[35], at[65]); MULADD(at[36], at[64]); MULADD(at[37], at[63]); MULADD(at[38], at[62]); MULADD(at[39], at[61]); MULADD(at[40], at[60]); MULADD(at[41], at[59]); MULADD(at[42], at[58]); MULADD(at[43], at[57]); MULADD(at[44], at[56]); MULADD(at[45], at[55]); MULADD(at[46], at[54]); MULADD(at[47], at[53]); + COMBA_STORE(C->dp[52]); + /* 53 */ + COMBA_FORWARD; + MULADD(at[6], at[95]); MULADD(at[7], at[94]); MULADD(at[8], at[93]); MULADD(at[9], at[92]); MULADD(at[10], at[91]); MULADD(at[11], at[90]); MULADD(at[12], at[89]); MULADD(at[13], at[88]); MULADD(at[14], at[87]); MULADD(at[15], at[86]); MULADD(at[16], at[85]); MULADD(at[17], at[84]); MULADD(at[18], at[83]); MULADD(at[19], at[82]); MULADD(at[20], at[81]); MULADD(at[21], at[80]); MULADD(at[22], at[79]); MULADD(at[23], at[78]); MULADD(at[24], at[77]); MULADD(at[25], at[76]); MULADD(at[26], at[75]); MULADD(at[27], at[74]); MULADD(at[28], at[73]); MULADD(at[29], at[72]); MULADD(at[30], at[71]); MULADD(at[31], at[70]); MULADD(at[32], at[69]); MULADD(at[33], at[68]); MULADD(at[34], at[67]); MULADD(at[35], at[66]); MULADD(at[36], at[65]); MULADD(at[37], at[64]); MULADD(at[38], at[63]); MULADD(at[39], at[62]); MULADD(at[40], at[61]); MULADD(at[41], at[60]); MULADD(at[42], at[59]); MULADD(at[43], at[58]); MULADD(at[44], at[57]); MULADD(at[45], at[56]); MULADD(at[46], at[55]); MULADD(at[47], at[54]); + COMBA_STORE(C->dp[53]); + /* 54 */ + COMBA_FORWARD; + MULADD(at[7], at[95]); MULADD(at[8], at[94]); MULADD(at[9], at[93]); MULADD(at[10], at[92]); MULADD(at[11], at[91]); MULADD(at[12], at[90]); MULADD(at[13], at[89]); MULADD(at[14], at[88]); MULADD(at[15], at[87]); MULADD(at[16], at[86]); MULADD(at[17], at[85]); MULADD(at[18], at[84]); MULADD(at[19], at[83]); MULADD(at[20], at[82]); MULADD(at[21], at[81]); MULADD(at[22], at[80]); MULADD(at[23], at[79]); MULADD(at[24], at[78]); MULADD(at[25], at[77]); MULADD(at[26], at[76]); MULADD(at[27], at[75]); MULADD(at[28], at[74]); MULADD(at[29], at[73]); MULADD(at[30], at[72]); MULADD(at[31], at[71]); MULADD(at[32], at[70]); MULADD(at[33], at[69]); MULADD(at[34], at[68]); MULADD(at[35], at[67]); MULADD(at[36], at[66]); MULADD(at[37], at[65]); MULADD(at[38], at[64]); MULADD(at[39], at[63]); MULADD(at[40], at[62]); MULADD(at[41], at[61]); MULADD(at[42], at[60]); MULADD(at[43], at[59]); MULADD(at[44], at[58]); MULADD(at[45], at[57]); MULADD(at[46], at[56]); MULADD(at[47], at[55]); + COMBA_STORE(C->dp[54]); + /* 55 */ + COMBA_FORWARD; + MULADD(at[8], at[95]); MULADD(at[9], at[94]); MULADD(at[10], at[93]); MULADD(at[11], at[92]); MULADD(at[12], at[91]); MULADD(at[13], at[90]); MULADD(at[14], at[89]); MULADD(at[15], at[88]); MULADD(at[16], at[87]); MULADD(at[17], at[86]); MULADD(at[18], at[85]); MULADD(at[19], at[84]); MULADD(at[20], at[83]); MULADD(at[21], at[82]); MULADD(at[22], at[81]); MULADD(at[23], at[80]); MULADD(at[24], at[79]); MULADD(at[25], at[78]); MULADD(at[26], at[77]); MULADD(at[27], at[76]); MULADD(at[28], at[75]); MULADD(at[29], at[74]); MULADD(at[30], at[73]); MULADD(at[31], at[72]); MULADD(at[32], at[71]); MULADD(at[33], at[70]); MULADD(at[34], at[69]); MULADD(at[35], at[68]); MULADD(at[36], at[67]); MULADD(at[37], at[66]); MULADD(at[38], at[65]); MULADD(at[39], at[64]); MULADD(at[40], at[63]); MULADD(at[41], at[62]); MULADD(at[42], at[61]); MULADD(at[43], at[60]); MULADD(at[44], at[59]); MULADD(at[45], at[58]); MULADD(at[46], at[57]); MULADD(at[47], at[56]); + COMBA_STORE(C->dp[55]); + /* 56 */ + COMBA_FORWARD; + MULADD(at[9], at[95]); MULADD(at[10], at[94]); MULADD(at[11], at[93]); MULADD(at[12], at[92]); MULADD(at[13], at[91]); MULADD(at[14], at[90]); MULADD(at[15], at[89]); MULADD(at[16], at[88]); MULADD(at[17], at[87]); MULADD(at[18], at[86]); MULADD(at[19], at[85]); MULADD(at[20], at[84]); MULADD(at[21], at[83]); MULADD(at[22], at[82]); MULADD(at[23], at[81]); MULADD(at[24], at[80]); MULADD(at[25], at[79]); MULADD(at[26], at[78]); MULADD(at[27], at[77]); MULADD(at[28], at[76]); MULADD(at[29], at[75]); MULADD(at[30], at[74]); MULADD(at[31], at[73]); MULADD(at[32], at[72]); MULADD(at[33], at[71]); MULADD(at[34], at[70]); MULADD(at[35], at[69]); MULADD(at[36], at[68]); MULADD(at[37], at[67]); MULADD(at[38], at[66]); MULADD(at[39], at[65]); MULADD(at[40], at[64]); MULADD(at[41], at[63]); MULADD(at[42], at[62]); MULADD(at[43], at[61]); MULADD(at[44], at[60]); MULADD(at[45], at[59]); MULADD(at[46], at[58]); MULADD(at[47], at[57]); + COMBA_STORE(C->dp[56]); + /* 57 */ + COMBA_FORWARD; + MULADD(at[10], at[95]); MULADD(at[11], at[94]); MULADD(at[12], at[93]); MULADD(at[13], at[92]); MULADD(at[14], at[91]); MULADD(at[15], at[90]); MULADD(at[16], at[89]); MULADD(at[17], at[88]); MULADD(at[18], at[87]); MULADD(at[19], at[86]); MULADD(at[20], at[85]); MULADD(at[21], at[84]); MULADD(at[22], at[83]); MULADD(at[23], at[82]); MULADD(at[24], at[81]); MULADD(at[25], at[80]); MULADD(at[26], at[79]); MULADD(at[27], at[78]); MULADD(at[28], at[77]); MULADD(at[29], at[76]); MULADD(at[30], at[75]); MULADD(at[31], at[74]); MULADD(at[32], at[73]); MULADD(at[33], at[72]); MULADD(at[34], at[71]); MULADD(at[35], at[70]); MULADD(at[36], at[69]); MULADD(at[37], at[68]); MULADD(at[38], at[67]); MULADD(at[39], at[66]); MULADD(at[40], at[65]); MULADD(at[41], at[64]); MULADD(at[42], at[63]); MULADD(at[43], at[62]); MULADD(at[44], at[61]); MULADD(at[45], at[60]); MULADD(at[46], at[59]); MULADD(at[47], at[58]); + COMBA_STORE(C->dp[57]); + /* 58 */ + COMBA_FORWARD; + MULADD(at[11], at[95]); MULADD(at[12], at[94]); MULADD(at[13], at[93]); MULADD(at[14], at[92]); MULADD(at[15], at[91]); MULADD(at[16], at[90]); MULADD(at[17], at[89]); MULADD(at[18], at[88]); MULADD(at[19], at[87]); MULADD(at[20], at[86]); MULADD(at[21], at[85]); MULADD(at[22], at[84]); MULADD(at[23], at[83]); MULADD(at[24], at[82]); MULADD(at[25], at[81]); MULADD(at[26], at[80]); MULADD(at[27], at[79]); MULADD(at[28], at[78]); MULADD(at[29], at[77]); MULADD(at[30], at[76]); MULADD(at[31], at[75]); MULADD(at[32], at[74]); MULADD(at[33], at[73]); MULADD(at[34], at[72]); MULADD(at[35], at[71]); MULADD(at[36], at[70]); MULADD(at[37], at[69]); MULADD(at[38], at[68]); MULADD(at[39], at[67]); MULADD(at[40], at[66]); MULADD(at[41], at[65]); MULADD(at[42], at[64]); MULADD(at[43], at[63]); MULADD(at[44], at[62]); MULADD(at[45], at[61]); MULADD(at[46], at[60]); MULADD(at[47], at[59]); + COMBA_STORE(C->dp[58]); + /* 59 */ + COMBA_FORWARD; + MULADD(at[12], at[95]); MULADD(at[13], at[94]); MULADD(at[14], at[93]); MULADD(at[15], at[92]); MULADD(at[16], at[91]); MULADD(at[17], at[90]); MULADD(at[18], at[89]); MULADD(at[19], at[88]); MULADD(at[20], at[87]); MULADD(at[21], at[86]); MULADD(at[22], at[85]); MULADD(at[23], at[84]); MULADD(at[24], at[83]); MULADD(at[25], at[82]); MULADD(at[26], at[81]); MULADD(at[27], at[80]); MULADD(at[28], at[79]); MULADD(at[29], at[78]); MULADD(at[30], at[77]); MULADD(at[31], at[76]); MULADD(at[32], at[75]); MULADD(at[33], at[74]); MULADD(at[34], at[73]); MULADD(at[35], at[72]); MULADD(at[36], at[71]); MULADD(at[37], at[70]); MULADD(at[38], at[69]); MULADD(at[39], at[68]); MULADD(at[40], at[67]); MULADD(at[41], at[66]); MULADD(at[42], at[65]); MULADD(at[43], at[64]); MULADD(at[44], at[63]); MULADD(at[45], at[62]); MULADD(at[46], at[61]); MULADD(at[47], at[60]); + COMBA_STORE(C->dp[59]); + /* 60 */ + COMBA_FORWARD; + MULADD(at[13], at[95]); MULADD(at[14], at[94]); MULADD(at[15], at[93]); MULADD(at[16], at[92]); MULADD(at[17], at[91]); MULADD(at[18], at[90]); MULADD(at[19], at[89]); MULADD(at[20], at[88]); MULADD(at[21], at[87]); MULADD(at[22], at[86]); MULADD(at[23], at[85]); MULADD(at[24], at[84]); MULADD(at[25], at[83]); MULADD(at[26], at[82]); MULADD(at[27], at[81]); MULADD(at[28], at[80]); MULADD(at[29], at[79]); MULADD(at[30], at[78]); MULADD(at[31], at[77]); MULADD(at[32], at[76]); MULADD(at[33], at[75]); MULADD(at[34], at[74]); MULADD(at[35], at[73]); MULADD(at[36], at[72]); MULADD(at[37], at[71]); MULADD(at[38], at[70]); MULADD(at[39], at[69]); MULADD(at[40], at[68]); MULADD(at[41], at[67]); MULADD(at[42], at[66]); MULADD(at[43], at[65]); MULADD(at[44], at[64]); MULADD(at[45], at[63]); MULADD(at[46], at[62]); MULADD(at[47], at[61]); + COMBA_STORE(C->dp[60]); + /* 61 */ + COMBA_FORWARD; + MULADD(at[14], at[95]); MULADD(at[15], at[94]); MULADD(at[16], at[93]); MULADD(at[17], at[92]); MULADD(at[18], at[91]); MULADD(at[19], at[90]); MULADD(at[20], at[89]); MULADD(at[21], at[88]); MULADD(at[22], at[87]); MULADD(at[23], at[86]); MULADD(at[24], at[85]); MULADD(at[25], at[84]); MULADD(at[26], at[83]); MULADD(at[27], at[82]); MULADD(at[28], at[81]); MULADD(at[29], at[80]); MULADD(at[30], at[79]); MULADD(at[31], at[78]); MULADD(at[32], at[77]); MULADD(at[33], at[76]); MULADD(at[34], at[75]); MULADD(at[35], at[74]); MULADD(at[36], at[73]); MULADD(at[37], at[72]); MULADD(at[38], at[71]); MULADD(at[39], at[70]); MULADD(at[40], at[69]); MULADD(at[41], at[68]); MULADD(at[42], at[67]); MULADD(at[43], at[66]); MULADD(at[44], at[65]); MULADD(at[45], at[64]); MULADD(at[46], at[63]); MULADD(at[47], at[62]); + COMBA_STORE(C->dp[61]); + /* 62 */ + COMBA_FORWARD; + MULADD(at[15], at[95]); MULADD(at[16], at[94]); MULADD(at[17], at[93]); MULADD(at[18], at[92]); MULADD(at[19], at[91]); MULADD(at[20], at[90]); MULADD(at[21], at[89]); MULADD(at[22], at[88]); MULADD(at[23], at[87]); MULADD(at[24], at[86]); MULADD(at[25], at[85]); MULADD(at[26], at[84]); MULADD(at[27], at[83]); MULADD(at[28], at[82]); MULADD(at[29], at[81]); MULADD(at[30], at[80]); MULADD(at[31], at[79]); MULADD(at[32], at[78]); MULADD(at[33], at[77]); MULADD(at[34], at[76]); MULADD(at[35], at[75]); MULADD(at[36], at[74]); MULADD(at[37], at[73]); MULADD(at[38], at[72]); MULADD(at[39], at[71]); MULADD(at[40], at[70]); MULADD(at[41], at[69]); MULADD(at[42], at[68]); MULADD(at[43], at[67]); MULADD(at[44], at[66]); MULADD(at[45], at[65]); MULADD(at[46], at[64]); MULADD(at[47], at[63]); + COMBA_STORE(C->dp[62]); + /* 63 */ + COMBA_FORWARD; + MULADD(at[16], at[95]); MULADD(at[17], at[94]); MULADD(at[18], at[93]); MULADD(at[19], at[92]); MULADD(at[20], at[91]); MULADD(at[21], at[90]); MULADD(at[22], at[89]); MULADD(at[23], at[88]); MULADD(at[24], at[87]); MULADD(at[25], at[86]); MULADD(at[26], at[85]); MULADD(at[27], at[84]); MULADD(at[28], at[83]); MULADD(at[29], at[82]); MULADD(at[30], at[81]); MULADD(at[31], at[80]); MULADD(at[32], at[79]); MULADD(at[33], at[78]); MULADD(at[34], at[77]); MULADD(at[35], at[76]); MULADD(at[36], at[75]); MULADD(at[37], at[74]); MULADD(at[38], at[73]); MULADD(at[39], at[72]); MULADD(at[40], at[71]); MULADD(at[41], at[70]); MULADD(at[42], at[69]); MULADD(at[43], at[68]); MULADD(at[44], at[67]); MULADD(at[45], at[66]); MULADD(at[46], at[65]); MULADD(at[47], at[64]); + COMBA_STORE(C->dp[63]); + /* 64 */ + COMBA_FORWARD; + MULADD(at[17], at[95]); MULADD(at[18], at[94]); MULADD(at[19], at[93]); MULADD(at[20], at[92]); MULADD(at[21], at[91]); MULADD(at[22], at[90]); MULADD(at[23], at[89]); MULADD(at[24], at[88]); MULADD(at[25], at[87]); MULADD(at[26], at[86]); MULADD(at[27], at[85]); MULADD(at[28], at[84]); MULADD(at[29], at[83]); MULADD(at[30], at[82]); MULADD(at[31], at[81]); MULADD(at[32], at[80]); MULADD(at[33], at[79]); MULADD(at[34], at[78]); MULADD(at[35], at[77]); MULADD(at[36], at[76]); MULADD(at[37], at[75]); MULADD(at[38], at[74]); MULADD(at[39], at[73]); MULADD(at[40], at[72]); MULADD(at[41], at[71]); MULADD(at[42], at[70]); MULADD(at[43], at[69]); MULADD(at[44], at[68]); MULADD(at[45], at[67]); MULADD(at[46], at[66]); MULADD(at[47], at[65]); + COMBA_STORE(C->dp[64]); + /* 65 */ + COMBA_FORWARD; + MULADD(at[18], at[95]); MULADD(at[19], at[94]); MULADD(at[20], at[93]); MULADD(at[21], at[92]); MULADD(at[22], at[91]); MULADD(at[23], at[90]); MULADD(at[24], at[89]); MULADD(at[25], at[88]); MULADD(at[26], at[87]); MULADD(at[27], at[86]); MULADD(at[28], at[85]); MULADD(at[29], at[84]); MULADD(at[30], at[83]); MULADD(at[31], at[82]); MULADD(at[32], at[81]); MULADD(at[33], at[80]); MULADD(at[34], at[79]); MULADD(at[35], at[78]); MULADD(at[36], at[77]); MULADD(at[37], at[76]); MULADD(at[38], at[75]); MULADD(at[39], at[74]); MULADD(at[40], at[73]); MULADD(at[41], at[72]); MULADD(at[42], at[71]); MULADD(at[43], at[70]); MULADD(at[44], at[69]); MULADD(at[45], at[68]); MULADD(at[46], at[67]); MULADD(at[47], at[66]); + COMBA_STORE(C->dp[65]); + /* 66 */ + COMBA_FORWARD; + MULADD(at[19], at[95]); MULADD(at[20], at[94]); MULADD(at[21], at[93]); MULADD(at[22], at[92]); MULADD(at[23], at[91]); MULADD(at[24], at[90]); MULADD(at[25], at[89]); MULADD(at[26], at[88]); MULADD(at[27], at[87]); MULADD(at[28], at[86]); MULADD(at[29], at[85]); MULADD(at[30], at[84]); MULADD(at[31], at[83]); MULADD(at[32], at[82]); MULADD(at[33], at[81]); MULADD(at[34], at[80]); MULADD(at[35], at[79]); MULADD(at[36], at[78]); MULADD(at[37], at[77]); MULADD(at[38], at[76]); MULADD(at[39], at[75]); MULADD(at[40], at[74]); MULADD(at[41], at[73]); MULADD(at[42], at[72]); MULADD(at[43], at[71]); MULADD(at[44], at[70]); MULADD(at[45], at[69]); MULADD(at[46], at[68]); MULADD(at[47], at[67]); + COMBA_STORE(C->dp[66]); + /* 67 */ + COMBA_FORWARD; + MULADD(at[20], at[95]); MULADD(at[21], at[94]); MULADD(at[22], at[93]); MULADD(at[23], at[92]); MULADD(at[24], at[91]); MULADD(at[25], at[90]); MULADD(at[26], at[89]); MULADD(at[27], at[88]); MULADD(at[28], at[87]); MULADD(at[29], at[86]); MULADD(at[30], at[85]); MULADD(at[31], at[84]); MULADD(at[32], at[83]); MULADD(at[33], at[82]); MULADD(at[34], at[81]); MULADD(at[35], at[80]); MULADD(at[36], at[79]); MULADD(at[37], at[78]); MULADD(at[38], at[77]); MULADD(at[39], at[76]); MULADD(at[40], at[75]); MULADD(at[41], at[74]); MULADD(at[42], at[73]); MULADD(at[43], at[72]); MULADD(at[44], at[71]); MULADD(at[45], at[70]); MULADD(at[46], at[69]); MULADD(at[47], at[68]); + COMBA_STORE(C->dp[67]); + /* 68 */ + COMBA_FORWARD; + MULADD(at[21], at[95]); MULADD(at[22], at[94]); MULADD(at[23], at[93]); MULADD(at[24], at[92]); MULADD(at[25], at[91]); MULADD(at[26], at[90]); MULADD(at[27], at[89]); MULADD(at[28], at[88]); MULADD(at[29], at[87]); MULADD(at[30], at[86]); MULADD(at[31], at[85]); MULADD(at[32], at[84]); MULADD(at[33], at[83]); MULADD(at[34], at[82]); MULADD(at[35], at[81]); MULADD(at[36], at[80]); MULADD(at[37], at[79]); MULADD(at[38], at[78]); MULADD(at[39], at[77]); MULADD(at[40], at[76]); MULADD(at[41], at[75]); MULADD(at[42], at[74]); MULADD(at[43], at[73]); MULADD(at[44], at[72]); MULADD(at[45], at[71]); MULADD(at[46], at[70]); MULADD(at[47], at[69]); + COMBA_STORE(C->dp[68]); + /* 69 */ + COMBA_FORWARD; + MULADD(at[22], at[95]); MULADD(at[23], at[94]); MULADD(at[24], at[93]); MULADD(at[25], at[92]); MULADD(at[26], at[91]); MULADD(at[27], at[90]); MULADD(at[28], at[89]); MULADD(at[29], at[88]); MULADD(at[30], at[87]); MULADD(at[31], at[86]); MULADD(at[32], at[85]); MULADD(at[33], at[84]); MULADD(at[34], at[83]); MULADD(at[35], at[82]); MULADD(at[36], at[81]); MULADD(at[37], at[80]); MULADD(at[38], at[79]); MULADD(at[39], at[78]); MULADD(at[40], at[77]); MULADD(at[41], at[76]); MULADD(at[42], at[75]); MULADD(at[43], at[74]); MULADD(at[44], at[73]); MULADD(at[45], at[72]); MULADD(at[46], at[71]); MULADD(at[47], at[70]); + COMBA_STORE(C->dp[69]); + /* 70 */ + COMBA_FORWARD; + MULADD(at[23], at[95]); MULADD(at[24], at[94]); MULADD(at[25], at[93]); MULADD(at[26], at[92]); MULADD(at[27], at[91]); MULADD(at[28], at[90]); MULADD(at[29], at[89]); MULADD(at[30], at[88]); MULADD(at[31], at[87]); MULADD(at[32], at[86]); MULADD(at[33], at[85]); MULADD(at[34], at[84]); MULADD(at[35], at[83]); MULADD(at[36], at[82]); MULADD(at[37], at[81]); MULADD(at[38], at[80]); MULADD(at[39], at[79]); MULADD(at[40], at[78]); MULADD(at[41], at[77]); MULADD(at[42], at[76]); MULADD(at[43], at[75]); MULADD(at[44], at[74]); MULADD(at[45], at[73]); MULADD(at[46], at[72]); MULADD(at[47], at[71]); + COMBA_STORE(C->dp[70]); + /* 71 */ + COMBA_FORWARD; + MULADD(at[24], at[95]); MULADD(at[25], at[94]); MULADD(at[26], at[93]); MULADD(at[27], at[92]); MULADD(at[28], at[91]); MULADD(at[29], at[90]); MULADD(at[30], at[89]); MULADD(at[31], at[88]); MULADD(at[32], at[87]); MULADD(at[33], at[86]); MULADD(at[34], at[85]); MULADD(at[35], at[84]); MULADD(at[36], at[83]); MULADD(at[37], at[82]); MULADD(at[38], at[81]); MULADD(at[39], at[80]); MULADD(at[40], at[79]); MULADD(at[41], at[78]); MULADD(at[42], at[77]); MULADD(at[43], at[76]); MULADD(at[44], at[75]); MULADD(at[45], at[74]); MULADD(at[46], at[73]); MULADD(at[47], at[72]); + COMBA_STORE(C->dp[71]); + /* 72 */ + COMBA_FORWARD; + MULADD(at[25], at[95]); MULADD(at[26], at[94]); MULADD(at[27], at[93]); MULADD(at[28], at[92]); MULADD(at[29], at[91]); MULADD(at[30], at[90]); MULADD(at[31], at[89]); MULADD(at[32], at[88]); MULADD(at[33], at[87]); MULADD(at[34], at[86]); MULADD(at[35], at[85]); MULADD(at[36], at[84]); MULADD(at[37], at[83]); MULADD(at[38], at[82]); MULADD(at[39], at[81]); MULADD(at[40], at[80]); MULADD(at[41], at[79]); MULADD(at[42], at[78]); MULADD(at[43], at[77]); MULADD(at[44], at[76]); MULADD(at[45], at[75]); MULADD(at[46], at[74]); MULADD(at[47], at[73]); + COMBA_STORE(C->dp[72]); + /* 73 */ + COMBA_FORWARD; + MULADD(at[26], at[95]); MULADD(at[27], at[94]); MULADD(at[28], at[93]); MULADD(at[29], at[92]); MULADD(at[30], at[91]); MULADD(at[31], at[90]); MULADD(at[32], at[89]); MULADD(at[33], at[88]); MULADD(at[34], at[87]); MULADD(at[35], at[86]); MULADD(at[36], at[85]); MULADD(at[37], at[84]); MULADD(at[38], at[83]); MULADD(at[39], at[82]); MULADD(at[40], at[81]); MULADD(at[41], at[80]); MULADD(at[42], at[79]); MULADD(at[43], at[78]); MULADD(at[44], at[77]); MULADD(at[45], at[76]); MULADD(at[46], at[75]); MULADD(at[47], at[74]); + COMBA_STORE(C->dp[73]); + /* 74 */ + COMBA_FORWARD; + MULADD(at[27], at[95]); MULADD(at[28], at[94]); MULADD(at[29], at[93]); MULADD(at[30], at[92]); MULADD(at[31], at[91]); MULADD(at[32], at[90]); MULADD(at[33], at[89]); MULADD(at[34], at[88]); MULADD(at[35], at[87]); MULADD(at[36], at[86]); MULADD(at[37], at[85]); MULADD(at[38], at[84]); MULADD(at[39], at[83]); MULADD(at[40], at[82]); MULADD(at[41], at[81]); MULADD(at[42], at[80]); MULADD(at[43], at[79]); MULADD(at[44], at[78]); MULADD(at[45], at[77]); MULADD(at[46], at[76]); MULADD(at[47], at[75]); + COMBA_STORE(C->dp[74]); + /* 75 */ + COMBA_FORWARD; + MULADD(at[28], at[95]); MULADD(at[29], at[94]); MULADD(at[30], at[93]); MULADD(at[31], at[92]); MULADD(at[32], at[91]); MULADD(at[33], at[90]); MULADD(at[34], at[89]); MULADD(at[35], at[88]); MULADD(at[36], at[87]); MULADD(at[37], at[86]); MULADD(at[38], at[85]); MULADD(at[39], at[84]); MULADD(at[40], at[83]); MULADD(at[41], at[82]); MULADD(at[42], at[81]); MULADD(at[43], at[80]); MULADD(at[44], at[79]); MULADD(at[45], at[78]); MULADD(at[46], at[77]); MULADD(at[47], at[76]); + COMBA_STORE(C->dp[75]); + /* 76 */ + COMBA_FORWARD; + MULADD(at[29], at[95]); MULADD(at[30], at[94]); MULADD(at[31], at[93]); MULADD(at[32], at[92]); MULADD(at[33], at[91]); MULADD(at[34], at[90]); MULADD(at[35], at[89]); MULADD(at[36], at[88]); MULADD(at[37], at[87]); MULADD(at[38], at[86]); MULADD(at[39], at[85]); MULADD(at[40], at[84]); MULADD(at[41], at[83]); MULADD(at[42], at[82]); MULADD(at[43], at[81]); MULADD(at[44], at[80]); MULADD(at[45], at[79]); MULADD(at[46], at[78]); MULADD(at[47], at[77]); + COMBA_STORE(C->dp[76]); + /* 77 */ + COMBA_FORWARD; + MULADD(at[30], at[95]); MULADD(at[31], at[94]); MULADD(at[32], at[93]); MULADD(at[33], at[92]); MULADD(at[34], at[91]); MULADD(at[35], at[90]); MULADD(at[36], at[89]); MULADD(at[37], at[88]); MULADD(at[38], at[87]); MULADD(at[39], at[86]); MULADD(at[40], at[85]); MULADD(at[41], at[84]); MULADD(at[42], at[83]); MULADD(at[43], at[82]); MULADD(at[44], at[81]); MULADD(at[45], at[80]); MULADD(at[46], at[79]); MULADD(at[47], at[78]); + COMBA_STORE(C->dp[77]); + /* 78 */ + COMBA_FORWARD; + MULADD(at[31], at[95]); MULADD(at[32], at[94]); MULADD(at[33], at[93]); MULADD(at[34], at[92]); MULADD(at[35], at[91]); MULADD(at[36], at[90]); MULADD(at[37], at[89]); MULADD(at[38], at[88]); MULADD(at[39], at[87]); MULADD(at[40], at[86]); MULADD(at[41], at[85]); MULADD(at[42], at[84]); MULADD(at[43], at[83]); MULADD(at[44], at[82]); MULADD(at[45], at[81]); MULADD(at[46], at[80]); MULADD(at[47], at[79]); + COMBA_STORE(C->dp[78]); + /* 79 */ + COMBA_FORWARD; + MULADD(at[32], at[95]); MULADD(at[33], at[94]); MULADD(at[34], at[93]); MULADD(at[35], at[92]); MULADD(at[36], at[91]); MULADD(at[37], at[90]); MULADD(at[38], at[89]); MULADD(at[39], at[88]); MULADD(at[40], at[87]); MULADD(at[41], at[86]); MULADD(at[42], at[85]); MULADD(at[43], at[84]); MULADD(at[44], at[83]); MULADD(at[45], at[82]); MULADD(at[46], at[81]); MULADD(at[47], at[80]); + COMBA_STORE(C->dp[79]); + /* 80 */ + COMBA_FORWARD; + MULADD(at[33], at[95]); MULADD(at[34], at[94]); MULADD(at[35], at[93]); MULADD(at[36], at[92]); MULADD(at[37], at[91]); MULADD(at[38], at[90]); MULADD(at[39], at[89]); MULADD(at[40], at[88]); MULADD(at[41], at[87]); MULADD(at[42], at[86]); MULADD(at[43], at[85]); MULADD(at[44], at[84]); MULADD(at[45], at[83]); MULADD(at[46], at[82]); MULADD(at[47], at[81]); + COMBA_STORE(C->dp[80]); + /* 81 */ + COMBA_FORWARD; + MULADD(at[34], at[95]); MULADD(at[35], at[94]); MULADD(at[36], at[93]); MULADD(at[37], at[92]); MULADD(at[38], at[91]); MULADD(at[39], at[90]); MULADD(at[40], at[89]); MULADD(at[41], at[88]); MULADD(at[42], at[87]); MULADD(at[43], at[86]); MULADD(at[44], at[85]); MULADD(at[45], at[84]); MULADD(at[46], at[83]); MULADD(at[47], at[82]); + COMBA_STORE(C->dp[81]); + /* 82 */ + COMBA_FORWARD; + MULADD(at[35], at[95]); MULADD(at[36], at[94]); MULADD(at[37], at[93]); MULADD(at[38], at[92]); MULADD(at[39], at[91]); MULADD(at[40], at[90]); MULADD(at[41], at[89]); MULADD(at[42], at[88]); MULADD(at[43], at[87]); MULADD(at[44], at[86]); MULADD(at[45], at[85]); MULADD(at[46], at[84]); MULADD(at[47], at[83]); + COMBA_STORE(C->dp[82]); + /* 83 */ + COMBA_FORWARD; + MULADD(at[36], at[95]); MULADD(at[37], at[94]); MULADD(at[38], at[93]); MULADD(at[39], at[92]); MULADD(at[40], at[91]); MULADD(at[41], at[90]); MULADD(at[42], at[89]); MULADD(at[43], at[88]); MULADD(at[44], at[87]); MULADD(at[45], at[86]); MULADD(at[46], at[85]); MULADD(at[47], at[84]); + COMBA_STORE(C->dp[83]); + /* 84 */ + COMBA_FORWARD; + MULADD(at[37], at[95]); MULADD(at[38], at[94]); MULADD(at[39], at[93]); MULADD(at[40], at[92]); MULADD(at[41], at[91]); MULADD(at[42], at[90]); MULADD(at[43], at[89]); MULADD(at[44], at[88]); MULADD(at[45], at[87]); MULADD(at[46], at[86]); MULADD(at[47], at[85]); + COMBA_STORE(C->dp[84]); + /* 85 */ + COMBA_FORWARD; + MULADD(at[38], at[95]); MULADD(at[39], at[94]); MULADD(at[40], at[93]); MULADD(at[41], at[92]); MULADD(at[42], at[91]); MULADD(at[43], at[90]); MULADD(at[44], at[89]); MULADD(at[45], at[88]); MULADD(at[46], at[87]); MULADD(at[47], at[86]); + COMBA_STORE(C->dp[85]); + /* 86 */ + COMBA_FORWARD; + MULADD(at[39], at[95]); MULADD(at[40], at[94]); MULADD(at[41], at[93]); MULADD(at[42], at[92]); MULADD(at[43], at[91]); MULADD(at[44], at[90]); MULADD(at[45], at[89]); MULADD(at[46], at[88]); MULADD(at[47], at[87]); + COMBA_STORE(C->dp[86]); + /* 87 */ + COMBA_FORWARD; + MULADD(at[40], at[95]); MULADD(at[41], at[94]); MULADD(at[42], at[93]); MULADD(at[43], at[92]); MULADD(at[44], at[91]); MULADD(at[45], at[90]); MULADD(at[46], at[89]); MULADD(at[47], at[88]); + COMBA_STORE(C->dp[87]); + /* 88 */ + COMBA_FORWARD; + MULADD(at[41], at[95]); MULADD(at[42], at[94]); MULADD(at[43], at[93]); MULADD(at[44], at[92]); MULADD(at[45], at[91]); MULADD(at[46], at[90]); MULADD(at[47], at[89]); + COMBA_STORE(C->dp[88]); + /* 89 */ + COMBA_FORWARD; + MULADD(at[42], at[95]); MULADD(at[43], at[94]); MULADD(at[44], at[93]); MULADD(at[45], at[92]); MULADD(at[46], at[91]); MULADD(at[47], at[90]); + COMBA_STORE(C->dp[89]); + /* 90 */ + COMBA_FORWARD; + MULADD(at[43], at[95]); MULADD(at[44], at[94]); MULADD(at[45], at[93]); MULADD(at[46], at[92]); MULADD(at[47], at[91]); + COMBA_STORE(C->dp[90]); + /* 91 */ + COMBA_FORWARD; + MULADD(at[44], at[95]); MULADD(at[45], at[94]); MULADD(at[46], at[93]); MULADD(at[47], at[92]); + COMBA_STORE(C->dp[91]); + /* 92 */ + COMBA_FORWARD; + MULADD(at[45], at[95]); MULADD(at[46], at[94]); MULADD(at[47], at[93]); + COMBA_STORE(C->dp[92]); + /* 93 */ + COMBA_FORWARD; + MULADD(at[46], at[95]); MULADD(at[47], at[94]); + COMBA_STORE(C->dp[93]); + /* 94 */ + COMBA_FORWARD; + MULADD(at[47], at[95]); + COMBA_STORE(C->dp[94]); + COMBA_STORE2(C->dp[95]); + C->used = 96; + C->sign = A->sign ^ B->sign; + fp_clamp(C); + COMBA_FINI; +} + + #endif + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mul_comba.c */ /* Start: fp_mul_d.c */ @@ -2742,7 +4925,7 @@ void fp_mul_comba32(fp_int *A, fp_int *B, fp_int *C) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -2772,6 +4955,10 @@ void fp_mul_d(fp_int *a, fp_digit b, fp_int *c) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mul_d.c */ /* Start: fp_mulmod.c */ @@ -2782,7 +4969,7 @@ void fp_mul_d(fp_int *a, fp_digit b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include /* d = a * b (mod c) */ @@ -2794,6 +4981,10 @@ int fp_mulmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) return fp_mod(&tmp, c, d); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_mulmod.c */ /* Start: fp_prime_miller_rabin.c */ @@ -2804,7 +4995,7 @@ int fp_mulmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -2871,6 +5062,10 @@ void fp_prime_miller_rabin (fp_int * a, fp_int * b, int *result) *result = FP_YES; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_prime_miller_rabin.c */ /* Start: fp_prime_random_ex.c */ @@ -2881,7 +5076,7 @@ void fp_prime_miller_rabin (fp_int * a, fp_int * b, int *result) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -2972,6 +5167,10 @@ error: return err; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_prime_random_ex.c */ /* Start: fp_radix_size.c */ @@ -2982,7 +5181,7 @@ error: * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3025,6 +5224,10 @@ int fp_radix_size(fp_int *a, int radix, int *size) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_radix_size.c */ /* Start: fp_read_radix.c */ @@ -3035,7 +5238,7 @@ int fp_radix_size(fp_int *a, int radix, int *size) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3095,6 +5298,10 @@ int fp_read_radix(fp_int *a, char *str, int radix) return FP_OKAY; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_read_radix.c */ /* Start: fp_read_signed_bin.c */ @@ -3105,7 +5312,7 @@ int fp_read_radix(fp_int *a, char *str, int radix) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3122,6 +5329,10 @@ void fp_read_signed_bin(fp_int *a, unsigned char *b, int c) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_read_signed_bin.c */ /* Start: fp_read_unsigned_bin.c */ @@ -3132,7 +5343,7 @@ void fp_read_signed_bin(fp_int *a, unsigned char *b, int c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3150,6 +5361,10 @@ void fp_read_unsigned_bin(fp_int *a, unsigned char *b, int c) fp_clamp (a); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_read_unsigned_bin.c */ /* Start: fp_reverse.c */ @@ -3160,7 +5375,7 @@ void fp_read_unsigned_bin(fp_int *a, unsigned char *b, int c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3181,6 +5396,10 @@ void bn_reverse (unsigned char *s, int len) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_reverse.c */ /* Start: fp_rshd.c */ @@ -3191,7 +5410,7 @@ void bn_reverse (unsigned char *s, int len) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3221,6 +5440,10 @@ void fp_rshd(fp_int *a, int x) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_rshd.c */ /* Start: fp_s_rmap.c */ @@ -3231,13 +5454,17 @@ void fp_rshd(fp_int *a, int x) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include /* chars used in radix conversions */ const char *fp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/"; +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_s_rmap.c */ /* Start: fp_set.c */ @@ -3248,7 +5475,7 @@ const char *fp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrs * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3259,6 +5486,10 @@ void fp_set(fp_int *a, fp_digit b) a->used = b ? 1 : 0; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_set.c */ /* Start: fp_signed_bin_size.c */ @@ -3269,7 +5500,7 @@ void fp_set(fp_int *a, fp_digit b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3278,6 +5509,10 @@ int fp_signed_bin_size(fp_int *a) return 1 + fp_unsigned_bin_size (a); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_signed_bin_size.c */ /* Start: fp_sqr.c */ @@ -3288,7 +5523,7 @@ int fp_signed_bin_size(fp_int *a) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -3300,21 +5535,26 @@ void fp_sqr(fp_int *A, fp_int *B) y = A->used; if (y <= 64) { - if (y <= 4) { - fp_sqr_comba4(A,B); - } else if (y <= 8) { - fp_sqr_comba8(A,B); -#if defined(TFM_LARGE) - } else if (y <= 16 && y >= 12) { - fp_sqr_comba16(A,B); + +#if defined(TFM_SMALL_SET) + if (y <= 16) { + fp_sqr_comba_small(A,B); +#elif defined(TFM_HUGE) + if (0) { 1; #endif #if defined(TFM_HUGE) - } else if (y <= 32 && y >= 20) { + } else if (y <= 32) { fp_sqr_comba32(A,B); - } else if (y <= 64 && y >= 48) { + } else if (y <= 48) { + fp_sqr_comba48(A,B); + } else if (y <= 64) { fp_sqr_comba64(A,B); #endif +#if !defined(TFM_SMALL_SET) && !defined(TFM_HUGE) + { +#else } else { +#endif fp_sqr_comba(A, B); } @@ -3393,6 +5633,10 @@ Obvious points of optimization } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_sqr.c */ /* Start: fp_sqr_comba.c */ @@ -3403,12 +5647,15 @@ Obvious points of optimization * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include -/* About this file... -*/ +#if defined(TFM_PRESCOTT) && defined(TFM_SSE2) + #undef TFM_SSE2 + #define TFM_X86 +#endif + #if defined(TFM_X86) @@ -3471,13 +5718,13 @@ asm ( \ #define SQRADDDB \ asm ( \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - :"=r"(c0), "=r"(c1), "=r"(c2), "=g"(sc0), "=g"(sc1), "=g"(sc2) : "0"(c0), "1"(c1), "2"(c2), "3"(sc0), "4"(sc1), "5"(sc2) : "%cc"); + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "%cc"); #elif defined(TFM_X86_64) /* x86-64 optimized */ @@ -3537,15 +5784,15 @@ asm ( \ "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 \ +#define SQRADDDB \ asm ( \ - "addq %3,%0 \n\t" \ - "adcq %4,%1 \n\t" \ - "adcq %5,%2 \n\t" \ - "addq %3,%0 \n\t" \ - "adcq %4,%1 \n\t" \ - "adcq %5,%2 \n\t" \ - :"=r"(c0), "=r"(c1), "=r"(c2), "=r"(sc0), "=r"(sc1), "=r"(sc2) : "0"(c0), "1"(c1), "2"(c2), "3"(sc0), "4"(sc1), "5"(sc2) : "%cc"); + "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"); #elif defined(TFM_SSE2) @@ -3598,14 +5845,13 @@ asm volatile ( \ #define SQRADDSC(i, j) \ asm volatile ( \ "movd %6,%%mm0 \n\t" \ - "pmuludq %%mm0,%%mm0\n\t" \ - "movd %%mm0,%%eax \n\t" \ + "movd %7,%%mm1 \n\t" \ + "pmuludq %%mm1,%%mm0\n\t" \ + "movd %%mm0,%0 \n\t" \ "psrlq $32,%%mm0 \n\t" \ - "movl %%eax,%0 \n\t" \ - "movd %%mm0,%%eax \n\t" \ - "movl %%eax,%1 \n\t" \ + "movd %%mm0,%1 \n\t" \ "xorl %2,%2 \n\t" \ - :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i) :"%eax","%cc"); + :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i), "m"(j)); #define SQRADDAC(i, j) \ asm volatile ( \ @@ -3618,20 +5864,17 @@ asm volatile ( \ "addl %%eax,%0 \n\t" \ "adcl %%edx,%1 \n\t" \ "adcl $0,%2 \n\t" \ - "addl %%eax,%0 \n\t" \ - "adcl %%edx,%1 \n\t" \ - "adcl $0,%2 \n\t" \ :"=r"(sc0), "=r"(sc1), "=r"(sc2): "0"(sc0), "1"(sc1), "2"(sc2), "m"(i), "m"(j) :"%eax","%edx","%cc"); -#define SQRADDDB \ +#define SQRADDDB \ asm ( \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - "addl %3,%0 \n\t" \ - "adcl %4,%1 \n\t" \ - "adcl %5,%2 \n\t" \ - :"=r"(c0), "=r"(c1), "=r"(c2), "=g"(sc0), "=g"(sc1), "=g"(sc2) : "0"(c0), "1"(c1), "2"(c2), "3"(sc0), "4"(sc1), "5"(sc2) : "%cc"); + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + "addl %6,%0 \n\t" \ + "adcl %7,%1 \n\t" \ + "adcl %8,%2 \n\t" \ + :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(sc0), "r"(sc1), "r"(sc2) : "%cc"); #elif defined(TFM_ARM) @@ -3690,13 +5933,82 @@ asm( \ #define SQRADDDB \ asm( \ -" ADDS %3,%0 \n\t" \ -" ADCS %4,%1 \n\t" \ -" ADC %5,%2 \n\t" \ -" ADDS %3,%0 \n\t" \ -" ADCS %4,%1 \n\t" \ -" ADC %5,%2 \n\t" \ -:"=r"(sc0), "=r"(sc1), "=r"(sc2), "=r"(c0), "=r"(c1), "=r"(c2) : "0"(sc0), "1"(sc1), "2"(sc2), "3"(c0), "4"(c1), "5"(c2) : "%cc"); +" ADDS %0,%0,%3 \n\t" \ +" ADCS %1,%1,%4 \n\t" \ +" ADC %2,%2,%5 \n\t" \ +" ADDS %0,%0,%3 \n\t" \ +" ADCS %1,%1,%4 \n\t" \ +" ADC %2,%2,%5 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc"); + +#elif defined(TFM_PPC32) + +/* PPC32 */ + +#define COMBA_START \ + +#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 \ + +/* multiplies point i and j, updates carry "c1" and digit c2 */ +#define SQRADD(i, j) \ +asm( \ + " mullw r16,%6,%6 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " mulhwu r16,%6,%6 \n\t" \ + " adde %1,%1,r16 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i):"r16","%cc"); + +/* for squaring some of the terms are doubled... */ +#define SQRADD2(i, j) \ +asm( \ + " mullw r16,%6,%7 \n\t" \ + " mulhwu r17,%6,%7 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " adde %1,%1,r17 \n\t" \ + " addze %2,%2 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " adde %1,%1,r17 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2):"0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j):"r16", "r17","%cc"); + +#define SQRADDSC(i, j) \ +asm( \ + " mullw %0,%6,%7 \n\t" \ + " mulhwu %1,%6,%7 \n\t" \ + " xor %2,%2,%2 \n\t" \ +:"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i),"r"(j) : "%cc"); + +#define SQRADDAC(i, j) \ +asm( \ + " mullw r16,%6,%7 \n\t" \ + " addc %0,%0,r16 \n\t" \ + " mulhwu r16,%6,%7 \n\t" \ + " adde %1,%1,r16 \n\t" \ + " addze %2,%2 \n\t" \ +:"=r"(sc0), "=r"(sc1), "=r"(sc2):"0"(sc0), "1"(sc1), "2"(sc2), "r"(i), "r"(j):"r16", "%cc"); + +#define SQRADDDB \ +asm( \ + " addc %0,%0,%3 \n\t" \ + " adde %1,%1,%4 \n\t" \ + " adde %2,%2,%5 \n\t" \ + " addc %0,%0,%3 \n\t" \ + " adde %1,%1,%4 \n\t" \ + " adde %2,%2,%5 \n\t" \ +:"=r"(c0), "=r"(c1), "=r"(c2) : "r"(sc0), "r"(sc1), "r"(sc2), "0"(c0), "1"(c1), "2"(c2) : "%cc"); #else @@ -3760,327 +6072,1521 @@ asm( \ #endif #include "fp_sqr_comba_generic.c" -void fp_sqr_comba4(fp_int *A, fp_int *B) -{ - fp_digit *a, b[8], 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[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 = FP_ZPOS; - memcpy(B->dp, b, 8 * sizeof(fp_digit)); - fp_clamp(B); -} - - -void fp_sqr_comba8(fp_int *A, fp_int *B) -{ - fp_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 = FP_ZPOS; - memcpy(B->dp, b, 16 * sizeof(fp_digit)); - fp_clamp(B); -} - - -#ifdef TFM_LARGE -void fp_sqr_comba16(fp_int *A, fp_int *B) +#if defined(TFM_SMALL_SET) +void fp_sqr_comba_small(fp_int *A, fp_int *B) { fp_digit *a, b[32], c0, c1, c2, sc0, sc1, sc2; + switch (A->used) { + case 1: + a = A->dp; + COMBA_START; - a = A->dp; - COMBA_START; + /* clear carries */ + CLEAR_CARRY; - /* clear carries */ - CLEAR_CARRY; + /* output 0 */ + SQRADD(a[0],a[0]); + COMBA_STORE(b[0]); + COMBA_STORE2(b[1]); + COMBA_FINI; - /* output 0 */ - SQRADD(a[0],a[0]); - COMBA_STORE(b[0]); + B->used = 2; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 2 * sizeof(fp_digit)); + fp_clamp(B); + break; - /* output 1 */ - CARRY_FORWARD; - SQRADD2(a[0], a[1]); - COMBA_STORE(b[1]); + case 2: + a = A->dp; + COMBA_START; - /* output 2 */ - CARRY_FORWARD; - SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]); - COMBA_STORE(b[2]); + /* clear carries */ + CLEAR_CARRY; - /* output 3 */ - CARRY_FORWARD; - SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]); - COMBA_STORE(b[3]); + /* output 0 */ + SQRADD(a[0],a[0]); + COMBA_STORE(b[0]); - /* output 4 */ - CARRY_FORWARD; - SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]); - COMBA_STORE(b[4]); + /* output 1 */ + CARRY_FORWARD; + SQRADD2(a[0], a[1]); + COMBA_STORE(b[1]); - /* output 5 */ - CARRY_FORWARD; + /* output 2 */ + CARRY_FORWARD; + SQRADD(a[1], a[1]); + COMBA_STORE(b[2]); + COMBA_STORE2(b[3]); + COMBA_FINI; + + B->used = 4; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 4 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 3: + 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[1], a[2]); + COMBA_STORE(b[3]); + + /* output 4 */ + CARRY_FORWARD; + SQRADD(a[2], a[2]); + COMBA_STORE(b[4]); + COMBA_STORE2(b[5]); + COMBA_FINI; + + B->used = 6; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 6 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 4: + 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 = FP_ZPOS; + memcpy(B->dp, b, 8 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 5: + 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; + SQRADD2(a[1], a[4]); SQRADD2(a[2], a[3]); + COMBA_STORE(b[5]); + + /* output 6 */ + CARRY_FORWARD; + SQRADD2(a[2], a[4]); SQRADD(a[3], a[3]); + COMBA_STORE(b[6]); + + /* output 7 */ + CARRY_FORWARD; + SQRADD2(a[3], a[4]); + COMBA_STORE(b[7]); + + /* output 8 */ + CARRY_FORWARD; + SQRADD(a[4], a[4]); + COMBA_STORE(b[8]); + COMBA_STORE2(b[9]); + COMBA_FINI; + + B->used = 10; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 10 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 6: + 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]); + COMBA_STORE(b[5]); - /* output 6 */ - CARRY_FORWARD; + /* output 6 */ + CARRY_FORWARD; + SQRADD2(a[1], a[5]); SQRADD2(a[2], a[4]); SQRADD(a[3], a[3]); + COMBA_STORE(b[6]); + + /* output 7 */ + CARRY_FORWARD; + SQRADD2(a[2], a[5]); SQRADD2(a[3], a[4]); + COMBA_STORE(b[7]); + + /* output 8 */ + CARRY_FORWARD; + SQRADD2(a[3], a[5]); SQRADD(a[4], a[4]); + COMBA_STORE(b[8]); + + /* output 9 */ + CARRY_FORWARD; + SQRADD2(a[4], a[5]); + COMBA_STORE(b[9]); + + /* output 10 */ + CARRY_FORWARD; + SQRADD(a[5], a[5]); + COMBA_STORE(b[10]); + COMBA_STORE2(b[11]); + COMBA_FINI; + + B->used = 12; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 12 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 7: + 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]); + COMBA_STORE(b[6]); - /* output 7 */ - CARRY_FORWARD; + /* output 7 */ + CARRY_FORWARD; + SQRADDSC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB; + COMBA_STORE(b[7]); + + /* output 8 */ + CARRY_FORWARD; + SQRADD2(a[2], a[6]); SQRADD2(a[3], a[5]); SQRADD(a[4], a[4]); + COMBA_STORE(b[8]); + + /* output 9 */ + CARRY_FORWARD; + SQRADD2(a[3], a[6]); SQRADD2(a[4], a[5]); + COMBA_STORE(b[9]); + + /* output 10 */ + CARRY_FORWARD; + SQRADD2(a[4], a[6]); SQRADD(a[5], a[5]); + COMBA_STORE(b[10]); + + /* output 11 */ + CARRY_FORWARD; + SQRADD2(a[5], a[6]); + COMBA_STORE(b[11]); + + /* output 12 */ + CARRY_FORWARD; + SQRADD(a[6], a[6]); + COMBA_STORE(b[12]); + COMBA_STORE2(b[13]); + COMBA_FINI; + + B->used = 14; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 14 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 8: + 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]); + COMBA_STORE(b[7]); - /* output 8 */ - CARRY_FORWARD; + /* 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 = FP_ZPOS; + memcpy(B->dp, b, 16 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 9: + 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]); + COMBA_STORE(b[8]); - /* output 9 */ - CARRY_FORWARD; + /* output 9 */ + CARRY_FORWARD; + SQRADDSC(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[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[3], a[8]); SQRADDAC(a[4], a[7]); SQRADDAC(a[5], a[6]); SQRADDDB; + COMBA_STORE(b[11]); + + /* output 12 */ + CARRY_FORWARD; + SQRADD2(a[4], a[8]); SQRADD2(a[5], a[7]); SQRADD(a[6], a[6]); + COMBA_STORE(b[12]); + + /* output 13 */ + CARRY_FORWARD; + SQRADD2(a[5], a[8]); SQRADD2(a[6], a[7]); + COMBA_STORE(b[13]); + + /* output 14 */ + CARRY_FORWARD; + SQRADD2(a[6], a[8]); SQRADD(a[7], a[7]); + COMBA_STORE(b[14]); + + /* output 15 */ + CARRY_FORWARD; + SQRADD2(a[7], a[8]); + COMBA_STORE(b[15]); + + /* output 16 */ + CARRY_FORWARD; + SQRADD(a[8], a[8]); + COMBA_STORE(b[16]); + COMBA_STORE2(b[17]); + COMBA_FINI; + + B->used = 18; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 18 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 10: + 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]); + COMBA_STORE(b[9]); - /* output 10 */ - CARRY_FORWARD; + /* output 10 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[4], a[9]); SQRADDAC(a[5], a[8]); SQRADDAC(a[6], a[7]); SQRADDDB; + COMBA_STORE(b[13]); + + /* output 14 */ + CARRY_FORWARD; + SQRADD2(a[5], a[9]); SQRADD2(a[6], a[8]); SQRADD(a[7], a[7]); + COMBA_STORE(b[14]); + + /* output 15 */ + CARRY_FORWARD; + SQRADD2(a[6], a[9]); SQRADD2(a[7], a[8]); + COMBA_STORE(b[15]); + + /* output 16 */ + CARRY_FORWARD; + SQRADD2(a[7], a[9]); SQRADD(a[8], a[8]); + COMBA_STORE(b[16]); + + /* output 17 */ + CARRY_FORWARD; + SQRADD2(a[8], a[9]); + COMBA_STORE(b[17]); + + /* output 18 */ + CARRY_FORWARD; + SQRADD(a[9], a[9]); + COMBA_STORE(b[18]); + COMBA_STORE2(b[19]); + COMBA_FINI; + + B->used = 20; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 20 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 11: + 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]); + COMBA_STORE(b[10]); - /* output 11 */ - CARRY_FORWARD; + /* output 11 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[5], a[10]); SQRADDAC(a[6], a[9]); SQRADDAC(a[7], a[8]); SQRADDDB; + COMBA_STORE(b[15]); + + /* output 16 */ + CARRY_FORWARD; + SQRADD2(a[6], a[10]); SQRADD2(a[7], a[9]); SQRADD(a[8], a[8]); + COMBA_STORE(b[16]); + + /* output 17 */ + CARRY_FORWARD; + SQRADD2(a[7], a[10]); SQRADD2(a[8], a[9]); + COMBA_STORE(b[17]); + + /* output 18 */ + CARRY_FORWARD; + SQRADD2(a[8], a[10]); SQRADD(a[9], a[9]); + COMBA_STORE(b[18]); + + /* output 19 */ + CARRY_FORWARD; + SQRADD2(a[9], a[10]); + COMBA_STORE(b[19]); + + /* output 20 */ + CARRY_FORWARD; + SQRADD(a[10], a[10]); + COMBA_STORE(b[20]); + COMBA_STORE2(b[21]); + COMBA_FINI; + + B->used = 22; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 22 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 12: + 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]); + COMBA_STORE(b[11]); - /* output 12 */ - CARRY_FORWARD; + /* output 12 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[6], a[11]); SQRADDAC(a[7], a[10]); SQRADDAC(a[8], a[9]); SQRADDDB; + COMBA_STORE(b[17]); + + /* output 18 */ + CARRY_FORWARD; + SQRADD2(a[7], a[11]); SQRADD2(a[8], a[10]); SQRADD(a[9], a[9]); + COMBA_STORE(b[18]); + + /* output 19 */ + CARRY_FORWARD; + SQRADD2(a[8], a[11]); SQRADD2(a[9], a[10]); + COMBA_STORE(b[19]); + + /* output 20 */ + CARRY_FORWARD; + SQRADD2(a[9], a[11]); SQRADD(a[10], a[10]); + COMBA_STORE(b[20]); + + /* output 21 */ + CARRY_FORWARD; + SQRADD2(a[10], a[11]); + COMBA_STORE(b[21]); + + /* output 22 */ + CARRY_FORWARD; + SQRADD(a[11], a[11]); + COMBA_STORE(b[22]); + COMBA_STORE2(b[23]); + COMBA_FINI; + + B->used = 24; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 24 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 13: + 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]); + COMBA_STORE(b[12]); - /* output 13 */ - CARRY_FORWARD; + /* output 13 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[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[7], a[12]); SQRADDAC(a[8], a[11]); SQRADDAC(a[9], a[10]); SQRADDDB; + COMBA_STORE(b[19]); + + /* output 20 */ + CARRY_FORWARD; + SQRADD2(a[8], a[12]); SQRADD2(a[9], a[11]); SQRADD(a[10], a[10]); + COMBA_STORE(b[20]); + + /* output 21 */ + CARRY_FORWARD; + SQRADD2(a[9], a[12]); SQRADD2(a[10], a[11]); + COMBA_STORE(b[21]); + + /* output 22 */ + CARRY_FORWARD; + SQRADD2(a[10], a[12]); SQRADD(a[11], a[11]); + COMBA_STORE(b[22]); + + /* output 23 */ + CARRY_FORWARD; + SQRADD2(a[11], a[12]); + COMBA_STORE(b[23]); + + /* output 24 */ + CARRY_FORWARD; + SQRADD(a[12], a[12]); + COMBA_STORE(b[24]); + COMBA_STORE2(b[25]); + COMBA_FINI; + + B->used = 26; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 26 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 14: + 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]); + COMBA_STORE(b[13]); - /* output 14 */ - CARRY_FORWARD; + /* output 14 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[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[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[8], a[13]); SQRADDAC(a[9], a[12]); SQRADDAC(a[10], a[11]); SQRADDDB; + COMBA_STORE(b[21]); + + /* output 22 */ + CARRY_FORWARD; + SQRADD2(a[9], a[13]); SQRADD2(a[10], a[12]); SQRADD(a[11], a[11]); + COMBA_STORE(b[22]); + + /* output 23 */ + CARRY_FORWARD; + SQRADD2(a[10], a[13]); SQRADD2(a[11], a[12]); + COMBA_STORE(b[23]); + + /* output 24 */ + CARRY_FORWARD; + SQRADD2(a[11], a[13]); SQRADD(a[12], a[12]); + COMBA_STORE(b[24]); + + /* output 25 */ + CARRY_FORWARD; + SQRADD2(a[12], a[13]); + COMBA_STORE(b[25]); + + /* output 26 */ + CARRY_FORWARD; + SQRADD(a[13], a[13]); + COMBA_STORE(b[26]); + COMBA_STORE2(b[27]); + COMBA_FINI; + + B->used = 28; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 28 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 15: + 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]); + COMBA_STORE(b[14]); - /* output 15 */ - CARRY_FORWARD; + /* output 15 */ + CARRY_FORWARD; + SQRADDSC(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[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[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[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[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[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[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[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[9], a[14]); SQRADDAC(a[10], a[13]); SQRADDAC(a[11], a[12]); SQRADDDB; + COMBA_STORE(b[23]); + + /* output 24 */ + CARRY_FORWARD; + SQRADD2(a[10], a[14]); SQRADD2(a[11], a[13]); SQRADD(a[12], a[12]); + COMBA_STORE(b[24]); + + /* output 25 */ + CARRY_FORWARD; + SQRADD2(a[11], a[14]); SQRADD2(a[12], a[13]); + COMBA_STORE(b[25]); + + /* output 26 */ + CARRY_FORWARD; + SQRADD2(a[12], a[14]); SQRADD(a[13], a[13]); + COMBA_STORE(b[26]); + + /* output 27 */ + CARRY_FORWARD; + SQRADD2(a[13], a[14]); + COMBA_STORE(b[27]); + + /* output 28 */ + CARRY_FORWARD; + SQRADD(a[14], a[14]); + COMBA_STORE(b[28]); + COMBA_STORE2(b[29]); + COMBA_FINI; + + B->used = 30; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 30 * sizeof(fp_digit)); + fp_clamp(B); + break; + + case 16: + 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]); + COMBA_STORE(b[15]); - /* output 16 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[16]); - /* output 17 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[17]); - /* output 18 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[18]); - /* output 19 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[19]); - /* output 20 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[20]); - /* output 21 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[21]); - /* output 22 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[22]); - /* output 23 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[23]); - /* output 24 */ - CARRY_FORWARD; + /* 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]); + COMBA_STORE(b[24]); - /* output 25 */ - CARRY_FORWARD; + /* output 25 */ + CARRY_FORWARD; SQRADDSC(a[10], a[15]); SQRADDAC(a[11], a[14]); SQRADDAC(a[12], a[13]); SQRADDDB; - COMBA_STORE(b[25]); + 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 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 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 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 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; + /* output 30 */ + CARRY_FORWARD; + SQRADD(a[15], a[15]); + COMBA_STORE(b[30]); + COMBA_STORE2(b[31]); + COMBA_FINI; - B->used = 32; - B->sign = FP_ZPOS; - memcpy(B->dp, b, 32 * sizeof(fp_digit)); - fp_clamp(B); + B->used = 32; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 32 * sizeof(fp_digit)); + fp_clamp(B); + break; +} } +#endif /* TFM_SMALL_SET */ + -#endif #ifdef TFM_HUGE void fp_sqr_comba32(fp_int *A, fp_int *B) { @@ -5070,12 +8576,519 @@ void fp_sqr_comba64(fp_int *A, fp_int *B) fp_clamp(B); } +void fp_sqr_comba48(fp_int *A, fp_int *B) +{ + fp_digit *a, b[96], 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[0], a[32]); SQRADDAC(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[0], a[33]); SQRADDAC(a[1], a[32]); SQRADDAC(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[0], a[34]); SQRADDAC(a[1], a[33]); SQRADDAC(a[2], a[32]); SQRADDAC(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[0], a[35]); SQRADDAC(a[1], a[34]); SQRADDAC(a[2], a[33]); SQRADDAC(a[3], a[32]); SQRADDAC(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[0], a[36]); SQRADDAC(a[1], a[35]); SQRADDAC(a[2], a[34]); SQRADDAC(a[3], a[33]); SQRADDAC(a[4], a[32]); SQRADDAC(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[0], a[37]); SQRADDAC(a[1], a[36]); SQRADDAC(a[2], a[35]); SQRADDAC(a[3], a[34]); SQRADDAC(a[4], a[33]); SQRADDAC(a[5], a[32]); SQRADDAC(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[0], a[38]); SQRADDAC(a[1], a[37]); SQRADDAC(a[2], a[36]); SQRADDAC(a[3], a[35]); SQRADDAC(a[4], a[34]); SQRADDAC(a[5], a[33]); SQRADDAC(a[6], a[32]); SQRADDAC(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[0], a[39]); SQRADDAC(a[1], a[38]); SQRADDAC(a[2], a[37]); SQRADDAC(a[3], a[36]); SQRADDAC(a[4], a[35]); SQRADDAC(a[5], a[34]); SQRADDAC(a[6], a[33]); SQRADDAC(a[7], a[32]); SQRADDAC(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[0], a[40]); SQRADDAC(a[1], a[39]); SQRADDAC(a[2], a[38]); SQRADDAC(a[3], a[37]); SQRADDAC(a[4], a[36]); SQRADDAC(a[5], a[35]); SQRADDAC(a[6], a[34]); SQRADDAC(a[7], a[33]); SQRADDAC(a[8], a[32]); SQRADDAC(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[0], a[41]); SQRADDAC(a[1], a[40]); SQRADDAC(a[2], a[39]); SQRADDAC(a[3], a[38]); SQRADDAC(a[4], a[37]); SQRADDAC(a[5], a[36]); SQRADDAC(a[6], a[35]); SQRADDAC(a[7], a[34]); SQRADDAC(a[8], a[33]); SQRADDAC(a[9], a[32]); SQRADDAC(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[0], a[42]); SQRADDAC(a[1], a[41]); SQRADDAC(a[2], a[40]); SQRADDAC(a[3], a[39]); SQRADDAC(a[4], a[38]); SQRADDAC(a[5], a[37]); SQRADDAC(a[6], a[36]); SQRADDAC(a[7], a[35]); SQRADDAC(a[8], a[34]); SQRADDAC(a[9], a[33]); SQRADDAC(a[10], a[32]); SQRADDAC(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[0], a[43]); SQRADDAC(a[1], a[42]); SQRADDAC(a[2], a[41]); SQRADDAC(a[3], a[40]); SQRADDAC(a[4], a[39]); SQRADDAC(a[5], a[38]); SQRADDAC(a[6], a[37]); SQRADDAC(a[7], a[36]); SQRADDAC(a[8], a[35]); SQRADDAC(a[9], a[34]); SQRADDAC(a[10], a[33]); SQRADDAC(a[11], a[32]); SQRADDAC(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[0], a[44]); SQRADDAC(a[1], a[43]); SQRADDAC(a[2], a[42]); SQRADDAC(a[3], a[41]); SQRADDAC(a[4], a[40]); SQRADDAC(a[5], a[39]); SQRADDAC(a[6], a[38]); SQRADDAC(a[7], a[37]); SQRADDAC(a[8], a[36]); SQRADDAC(a[9], a[35]); SQRADDAC(a[10], a[34]); SQRADDAC(a[11], a[33]); SQRADDAC(a[12], a[32]); SQRADDAC(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[0], a[45]); SQRADDAC(a[1], a[44]); SQRADDAC(a[2], a[43]); SQRADDAC(a[3], a[42]); SQRADDAC(a[4], a[41]); SQRADDAC(a[5], a[40]); SQRADDAC(a[6], a[39]); SQRADDAC(a[7], a[38]); SQRADDAC(a[8], a[37]); SQRADDAC(a[9], a[36]); SQRADDAC(a[10], a[35]); SQRADDAC(a[11], a[34]); SQRADDAC(a[12], a[33]); SQRADDAC(a[13], a[32]); SQRADDAC(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[0], a[46]); SQRADDAC(a[1], a[45]); SQRADDAC(a[2], a[44]); SQRADDAC(a[3], a[43]); SQRADDAC(a[4], a[42]); SQRADDAC(a[5], a[41]); SQRADDAC(a[6], a[40]); SQRADDAC(a[7], a[39]); SQRADDAC(a[8], a[38]); SQRADDAC(a[9], a[37]); SQRADDAC(a[10], a[36]); SQRADDAC(a[11], a[35]); SQRADDAC(a[12], a[34]); SQRADDAC(a[13], a[33]); SQRADDAC(a[14], a[32]); SQRADDAC(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[0], a[47]); SQRADDAC(a[1], a[46]); SQRADDAC(a[2], a[45]); SQRADDAC(a[3], a[44]); SQRADDAC(a[4], a[43]); SQRADDAC(a[5], a[42]); SQRADDAC(a[6], a[41]); SQRADDAC(a[7], a[40]); SQRADDAC(a[8], a[39]); SQRADDAC(a[9], a[38]); SQRADDAC(a[10], a[37]); SQRADDAC(a[11], a[36]); SQRADDAC(a[12], a[35]); SQRADDAC(a[13], a[34]); SQRADDAC(a[14], a[33]); SQRADDAC(a[15], a[32]); SQRADDAC(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[1], a[47]); SQRADDAC(a[2], a[46]); SQRADDAC(a[3], a[45]); SQRADDAC(a[4], a[44]); SQRADDAC(a[5], a[43]); SQRADDAC(a[6], a[42]); SQRADDAC(a[7], a[41]); SQRADDAC(a[8], a[40]); SQRADDAC(a[9], a[39]); SQRADDAC(a[10], a[38]); SQRADDAC(a[11], a[37]); SQRADDAC(a[12], a[36]); SQRADDAC(a[13], a[35]); SQRADDAC(a[14], a[34]); SQRADDAC(a[15], a[33]); SQRADDAC(a[16], a[32]); SQRADDAC(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[2], a[47]); SQRADDAC(a[3], a[46]); SQRADDAC(a[4], a[45]); SQRADDAC(a[5], a[44]); SQRADDAC(a[6], a[43]); SQRADDAC(a[7], a[42]); SQRADDAC(a[8], a[41]); SQRADDAC(a[9], a[40]); SQRADDAC(a[10], a[39]); SQRADDAC(a[11], a[38]); SQRADDAC(a[12], a[37]); SQRADDAC(a[13], a[36]); SQRADDAC(a[14], a[35]); SQRADDAC(a[15], a[34]); SQRADDAC(a[16], a[33]); SQRADDAC(a[17], a[32]); SQRADDAC(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[3], a[47]); SQRADDAC(a[4], a[46]); SQRADDAC(a[5], a[45]); SQRADDAC(a[6], a[44]); SQRADDAC(a[7], a[43]); SQRADDAC(a[8], a[42]); SQRADDAC(a[9], a[41]); SQRADDAC(a[10], a[40]); SQRADDAC(a[11], a[39]); SQRADDAC(a[12], a[38]); SQRADDAC(a[13], a[37]); SQRADDAC(a[14], a[36]); SQRADDAC(a[15], a[35]); SQRADDAC(a[16], a[34]); SQRADDAC(a[17], a[33]); SQRADDAC(a[18], a[32]); SQRADDAC(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[4], a[47]); SQRADDAC(a[5], a[46]); SQRADDAC(a[6], a[45]); SQRADDAC(a[7], a[44]); SQRADDAC(a[8], a[43]); SQRADDAC(a[9], a[42]); SQRADDAC(a[10], a[41]); SQRADDAC(a[11], a[40]); SQRADDAC(a[12], a[39]); SQRADDAC(a[13], a[38]); SQRADDAC(a[14], a[37]); SQRADDAC(a[15], a[36]); SQRADDAC(a[16], a[35]); SQRADDAC(a[17], a[34]); SQRADDAC(a[18], a[33]); SQRADDAC(a[19], a[32]); SQRADDAC(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[5], a[47]); SQRADDAC(a[6], a[46]); SQRADDAC(a[7], a[45]); SQRADDAC(a[8], a[44]); SQRADDAC(a[9], a[43]); SQRADDAC(a[10], a[42]); SQRADDAC(a[11], a[41]); SQRADDAC(a[12], a[40]); SQRADDAC(a[13], a[39]); SQRADDAC(a[14], a[38]); SQRADDAC(a[15], a[37]); SQRADDAC(a[16], a[36]); SQRADDAC(a[17], a[35]); SQRADDAC(a[18], a[34]); SQRADDAC(a[19], a[33]); SQRADDAC(a[20], a[32]); SQRADDAC(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[6], a[47]); SQRADDAC(a[7], a[46]); SQRADDAC(a[8], a[45]); SQRADDAC(a[9], a[44]); SQRADDAC(a[10], a[43]); SQRADDAC(a[11], a[42]); SQRADDAC(a[12], a[41]); SQRADDAC(a[13], a[40]); SQRADDAC(a[14], a[39]); SQRADDAC(a[15], a[38]); SQRADDAC(a[16], a[37]); SQRADDAC(a[17], a[36]); SQRADDAC(a[18], a[35]); SQRADDAC(a[19], a[34]); SQRADDAC(a[20], a[33]); SQRADDAC(a[21], a[32]); SQRADDAC(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[7], a[47]); SQRADDAC(a[8], a[46]); SQRADDAC(a[9], a[45]); SQRADDAC(a[10], a[44]); SQRADDAC(a[11], a[43]); SQRADDAC(a[12], a[42]); SQRADDAC(a[13], a[41]); SQRADDAC(a[14], a[40]); SQRADDAC(a[15], a[39]); SQRADDAC(a[16], a[38]); SQRADDAC(a[17], a[37]); SQRADDAC(a[18], a[36]); SQRADDAC(a[19], a[35]); SQRADDAC(a[20], a[34]); SQRADDAC(a[21], a[33]); SQRADDAC(a[22], a[32]); SQRADDAC(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[8], a[47]); SQRADDAC(a[9], a[46]); SQRADDAC(a[10], a[45]); SQRADDAC(a[11], a[44]); SQRADDAC(a[12], a[43]); SQRADDAC(a[13], a[42]); SQRADDAC(a[14], a[41]); SQRADDAC(a[15], a[40]); SQRADDAC(a[16], a[39]); SQRADDAC(a[17], a[38]); SQRADDAC(a[18], a[37]); SQRADDAC(a[19], a[36]); SQRADDAC(a[20], a[35]); SQRADDAC(a[21], a[34]); SQRADDAC(a[22], a[33]); SQRADDAC(a[23], a[32]); SQRADDAC(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[9], a[47]); SQRADDAC(a[10], a[46]); SQRADDAC(a[11], a[45]); SQRADDAC(a[12], a[44]); SQRADDAC(a[13], a[43]); SQRADDAC(a[14], a[42]); SQRADDAC(a[15], a[41]); SQRADDAC(a[16], a[40]); SQRADDAC(a[17], a[39]); SQRADDAC(a[18], a[38]); SQRADDAC(a[19], a[37]); SQRADDAC(a[20], a[36]); SQRADDAC(a[21], a[35]); SQRADDAC(a[22], a[34]); SQRADDAC(a[23], a[33]); SQRADDAC(a[24], a[32]); SQRADDAC(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[10], a[47]); SQRADDAC(a[11], a[46]); SQRADDAC(a[12], a[45]); SQRADDAC(a[13], a[44]); SQRADDAC(a[14], a[43]); SQRADDAC(a[15], a[42]); SQRADDAC(a[16], a[41]); SQRADDAC(a[17], a[40]); SQRADDAC(a[18], a[39]); SQRADDAC(a[19], a[38]); SQRADDAC(a[20], a[37]); SQRADDAC(a[21], a[36]); SQRADDAC(a[22], a[35]); SQRADDAC(a[23], a[34]); SQRADDAC(a[24], a[33]); SQRADDAC(a[25], a[32]); SQRADDAC(a[26], a[31]); SQRADDAC(a[27], a[30]); SQRADDAC(a[28], a[29]); SQRADDDB; + COMBA_STORE(b[57]); + + /* output 58 */ + CARRY_FORWARD; + SQRADDSC(a[11], a[47]); SQRADDAC(a[12], a[46]); SQRADDAC(a[13], a[45]); SQRADDAC(a[14], a[44]); SQRADDAC(a[15], a[43]); SQRADDAC(a[16], a[42]); SQRADDAC(a[17], a[41]); SQRADDAC(a[18], a[40]); SQRADDAC(a[19], a[39]); SQRADDAC(a[20], a[38]); SQRADDAC(a[21], a[37]); SQRADDAC(a[22], a[36]); SQRADDAC(a[23], a[35]); SQRADDAC(a[24], a[34]); SQRADDAC(a[25], a[33]); SQRADDAC(a[26], a[32]); SQRADDAC(a[27], a[31]); SQRADDAC(a[28], a[30]); SQRADDDB; SQRADD(a[29], a[29]); + COMBA_STORE(b[58]); + + /* output 59 */ + CARRY_FORWARD; + SQRADDSC(a[12], a[47]); SQRADDAC(a[13], a[46]); SQRADDAC(a[14], a[45]); SQRADDAC(a[15], a[44]); SQRADDAC(a[16], a[43]); SQRADDAC(a[17], a[42]); SQRADDAC(a[18], a[41]); SQRADDAC(a[19], a[40]); SQRADDAC(a[20], a[39]); SQRADDAC(a[21], a[38]); SQRADDAC(a[22], a[37]); SQRADDAC(a[23], a[36]); SQRADDAC(a[24], a[35]); SQRADDAC(a[25], a[34]); SQRADDAC(a[26], a[33]); SQRADDAC(a[27], a[32]); SQRADDAC(a[28], a[31]); SQRADDAC(a[29], a[30]); SQRADDDB; + COMBA_STORE(b[59]); + + /* output 60 */ + CARRY_FORWARD; + SQRADDSC(a[13], a[47]); SQRADDAC(a[14], a[46]); SQRADDAC(a[15], a[45]); SQRADDAC(a[16], a[44]); SQRADDAC(a[17], a[43]); SQRADDAC(a[18], a[42]); SQRADDAC(a[19], a[41]); SQRADDAC(a[20], a[40]); SQRADDAC(a[21], a[39]); SQRADDAC(a[22], a[38]); SQRADDAC(a[23], a[37]); SQRADDAC(a[24], a[36]); SQRADDAC(a[25], a[35]); SQRADDAC(a[26], a[34]); SQRADDAC(a[27], a[33]); SQRADDAC(a[28], a[32]); SQRADDAC(a[29], a[31]); SQRADDDB; SQRADD(a[30], a[30]); + COMBA_STORE(b[60]); + + /* output 61 */ + CARRY_FORWARD; + SQRADDSC(a[14], a[47]); SQRADDAC(a[15], a[46]); SQRADDAC(a[16], a[45]); SQRADDAC(a[17], a[44]); SQRADDAC(a[18], a[43]); SQRADDAC(a[19], a[42]); SQRADDAC(a[20], a[41]); SQRADDAC(a[21], a[40]); SQRADDAC(a[22], a[39]); SQRADDAC(a[23], a[38]); SQRADDAC(a[24], a[37]); SQRADDAC(a[25], a[36]); SQRADDAC(a[26], a[35]); SQRADDAC(a[27], a[34]); SQRADDAC(a[28], a[33]); SQRADDAC(a[29], a[32]); SQRADDAC(a[30], a[31]); SQRADDDB; + COMBA_STORE(b[61]); + + /* output 62 */ + CARRY_FORWARD; + SQRADDSC(a[15], a[47]); SQRADDAC(a[16], a[46]); SQRADDAC(a[17], a[45]); SQRADDAC(a[18], a[44]); SQRADDAC(a[19], a[43]); SQRADDAC(a[20], a[42]); SQRADDAC(a[21], a[41]); SQRADDAC(a[22], a[40]); SQRADDAC(a[23], a[39]); SQRADDAC(a[24], a[38]); SQRADDAC(a[25], a[37]); SQRADDAC(a[26], a[36]); SQRADDAC(a[27], a[35]); SQRADDAC(a[28], a[34]); SQRADDAC(a[29], a[33]); SQRADDAC(a[30], a[32]); SQRADDDB; SQRADD(a[31], a[31]); + COMBA_STORE(b[62]); + + /* output 63 */ + CARRY_FORWARD; + SQRADDSC(a[16], a[47]); SQRADDAC(a[17], a[46]); SQRADDAC(a[18], a[45]); SQRADDAC(a[19], a[44]); SQRADDAC(a[20], a[43]); SQRADDAC(a[21], a[42]); SQRADDAC(a[22], a[41]); SQRADDAC(a[23], a[40]); SQRADDAC(a[24], a[39]); SQRADDAC(a[25], a[38]); SQRADDAC(a[26], a[37]); SQRADDAC(a[27], a[36]); SQRADDAC(a[28], a[35]); SQRADDAC(a[29], a[34]); SQRADDAC(a[30], a[33]); SQRADDAC(a[31], a[32]); SQRADDDB; + COMBA_STORE(b[63]); + + /* output 64 */ + CARRY_FORWARD; + SQRADDSC(a[17], a[47]); SQRADDAC(a[18], a[46]); SQRADDAC(a[19], a[45]); SQRADDAC(a[20], a[44]); SQRADDAC(a[21], a[43]); SQRADDAC(a[22], a[42]); SQRADDAC(a[23], a[41]); SQRADDAC(a[24], a[40]); SQRADDAC(a[25], a[39]); SQRADDAC(a[26], a[38]); SQRADDAC(a[27], a[37]); SQRADDAC(a[28], a[36]); SQRADDAC(a[29], a[35]); SQRADDAC(a[30], a[34]); SQRADDAC(a[31], a[33]); SQRADDDB; SQRADD(a[32], a[32]); + COMBA_STORE(b[64]); + + /* output 65 */ + CARRY_FORWARD; + SQRADDSC(a[18], a[47]); SQRADDAC(a[19], a[46]); SQRADDAC(a[20], a[45]); SQRADDAC(a[21], a[44]); SQRADDAC(a[22], a[43]); SQRADDAC(a[23], a[42]); SQRADDAC(a[24], a[41]); SQRADDAC(a[25], a[40]); SQRADDAC(a[26], a[39]); SQRADDAC(a[27], a[38]); SQRADDAC(a[28], a[37]); SQRADDAC(a[29], a[36]); SQRADDAC(a[30], a[35]); SQRADDAC(a[31], a[34]); SQRADDAC(a[32], a[33]); SQRADDDB; + COMBA_STORE(b[65]); + + /* output 66 */ + CARRY_FORWARD; + SQRADDSC(a[19], a[47]); SQRADDAC(a[20], a[46]); SQRADDAC(a[21], a[45]); SQRADDAC(a[22], a[44]); SQRADDAC(a[23], a[43]); SQRADDAC(a[24], a[42]); SQRADDAC(a[25], a[41]); SQRADDAC(a[26], a[40]); SQRADDAC(a[27], a[39]); SQRADDAC(a[28], a[38]); SQRADDAC(a[29], a[37]); SQRADDAC(a[30], a[36]); SQRADDAC(a[31], a[35]); SQRADDAC(a[32], a[34]); SQRADDDB; SQRADD(a[33], a[33]); + COMBA_STORE(b[66]); + + /* output 67 */ + CARRY_FORWARD; + SQRADDSC(a[20], a[47]); SQRADDAC(a[21], a[46]); SQRADDAC(a[22], a[45]); SQRADDAC(a[23], a[44]); SQRADDAC(a[24], a[43]); SQRADDAC(a[25], a[42]); SQRADDAC(a[26], a[41]); SQRADDAC(a[27], a[40]); SQRADDAC(a[28], a[39]); SQRADDAC(a[29], a[38]); SQRADDAC(a[30], a[37]); SQRADDAC(a[31], a[36]); SQRADDAC(a[32], a[35]); SQRADDAC(a[33], a[34]); SQRADDDB; + COMBA_STORE(b[67]); + + /* output 68 */ + CARRY_FORWARD; + SQRADDSC(a[21], a[47]); SQRADDAC(a[22], a[46]); SQRADDAC(a[23], a[45]); SQRADDAC(a[24], a[44]); SQRADDAC(a[25], a[43]); SQRADDAC(a[26], a[42]); SQRADDAC(a[27], a[41]); SQRADDAC(a[28], a[40]); SQRADDAC(a[29], a[39]); SQRADDAC(a[30], a[38]); SQRADDAC(a[31], a[37]); SQRADDAC(a[32], a[36]); SQRADDAC(a[33], a[35]); SQRADDDB; SQRADD(a[34], a[34]); + COMBA_STORE(b[68]); + + /* output 69 */ + CARRY_FORWARD; + SQRADDSC(a[22], a[47]); SQRADDAC(a[23], a[46]); SQRADDAC(a[24], a[45]); SQRADDAC(a[25], a[44]); SQRADDAC(a[26], a[43]); SQRADDAC(a[27], a[42]); SQRADDAC(a[28], a[41]); SQRADDAC(a[29], a[40]); SQRADDAC(a[30], a[39]); SQRADDAC(a[31], a[38]); SQRADDAC(a[32], a[37]); SQRADDAC(a[33], a[36]); SQRADDAC(a[34], a[35]); SQRADDDB; + COMBA_STORE(b[69]); + + /* output 70 */ + CARRY_FORWARD; + SQRADDSC(a[23], a[47]); SQRADDAC(a[24], a[46]); SQRADDAC(a[25], a[45]); SQRADDAC(a[26], a[44]); SQRADDAC(a[27], a[43]); SQRADDAC(a[28], a[42]); SQRADDAC(a[29], a[41]); SQRADDAC(a[30], a[40]); SQRADDAC(a[31], a[39]); SQRADDAC(a[32], a[38]); SQRADDAC(a[33], a[37]); SQRADDAC(a[34], a[36]); SQRADDDB; SQRADD(a[35], a[35]); + COMBA_STORE(b[70]); + + /* output 71 */ + CARRY_FORWARD; + SQRADDSC(a[24], a[47]); SQRADDAC(a[25], a[46]); SQRADDAC(a[26], a[45]); SQRADDAC(a[27], a[44]); SQRADDAC(a[28], a[43]); SQRADDAC(a[29], a[42]); SQRADDAC(a[30], a[41]); SQRADDAC(a[31], a[40]); SQRADDAC(a[32], a[39]); SQRADDAC(a[33], a[38]); SQRADDAC(a[34], a[37]); SQRADDAC(a[35], a[36]); SQRADDDB; + COMBA_STORE(b[71]); + + /* output 72 */ + CARRY_FORWARD; + SQRADDSC(a[25], a[47]); SQRADDAC(a[26], a[46]); SQRADDAC(a[27], a[45]); SQRADDAC(a[28], a[44]); SQRADDAC(a[29], a[43]); SQRADDAC(a[30], a[42]); SQRADDAC(a[31], a[41]); SQRADDAC(a[32], a[40]); SQRADDAC(a[33], a[39]); SQRADDAC(a[34], a[38]); SQRADDAC(a[35], a[37]); SQRADDDB; SQRADD(a[36], a[36]); + COMBA_STORE(b[72]); + + /* output 73 */ + CARRY_FORWARD; + SQRADDSC(a[26], a[47]); SQRADDAC(a[27], a[46]); SQRADDAC(a[28], a[45]); SQRADDAC(a[29], a[44]); SQRADDAC(a[30], a[43]); SQRADDAC(a[31], a[42]); SQRADDAC(a[32], a[41]); SQRADDAC(a[33], a[40]); SQRADDAC(a[34], a[39]); SQRADDAC(a[35], a[38]); SQRADDAC(a[36], a[37]); SQRADDDB; + COMBA_STORE(b[73]); + + /* output 74 */ + CARRY_FORWARD; + SQRADDSC(a[27], a[47]); SQRADDAC(a[28], a[46]); SQRADDAC(a[29], a[45]); SQRADDAC(a[30], a[44]); SQRADDAC(a[31], a[43]); SQRADDAC(a[32], a[42]); SQRADDAC(a[33], a[41]); SQRADDAC(a[34], a[40]); SQRADDAC(a[35], a[39]); SQRADDAC(a[36], a[38]); SQRADDDB; SQRADD(a[37], a[37]); + COMBA_STORE(b[74]); + + /* output 75 */ + CARRY_FORWARD; + SQRADDSC(a[28], a[47]); SQRADDAC(a[29], a[46]); SQRADDAC(a[30], a[45]); SQRADDAC(a[31], a[44]); SQRADDAC(a[32], a[43]); SQRADDAC(a[33], a[42]); SQRADDAC(a[34], a[41]); SQRADDAC(a[35], a[40]); SQRADDAC(a[36], a[39]); SQRADDAC(a[37], a[38]); SQRADDDB; + COMBA_STORE(b[75]); + + /* output 76 */ + CARRY_FORWARD; + SQRADDSC(a[29], a[47]); SQRADDAC(a[30], a[46]); SQRADDAC(a[31], a[45]); SQRADDAC(a[32], a[44]); SQRADDAC(a[33], a[43]); SQRADDAC(a[34], a[42]); SQRADDAC(a[35], a[41]); SQRADDAC(a[36], a[40]); SQRADDAC(a[37], a[39]); SQRADDDB; SQRADD(a[38], a[38]); + COMBA_STORE(b[76]); + + /* output 77 */ + CARRY_FORWARD; + SQRADDSC(a[30], a[47]); SQRADDAC(a[31], a[46]); SQRADDAC(a[32], a[45]); SQRADDAC(a[33], a[44]); SQRADDAC(a[34], a[43]); SQRADDAC(a[35], a[42]); SQRADDAC(a[36], a[41]); SQRADDAC(a[37], a[40]); SQRADDAC(a[38], a[39]); SQRADDDB; + COMBA_STORE(b[77]); + + /* output 78 */ + CARRY_FORWARD; + SQRADDSC(a[31], a[47]); SQRADDAC(a[32], a[46]); SQRADDAC(a[33], a[45]); SQRADDAC(a[34], a[44]); SQRADDAC(a[35], a[43]); SQRADDAC(a[36], a[42]); SQRADDAC(a[37], a[41]); SQRADDAC(a[38], a[40]); SQRADDDB; SQRADD(a[39], a[39]); + COMBA_STORE(b[78]); + + /* output 79 */ + CARRY_FORWARD; + SQRADDSC(a[32], a[47]); SQRADDAC(a[33], a[46]); SQRADDAC(a[34], a[45]); SQRADDAC(a[35], a[44]); SQRADDAC(a[36], a[43]); SQRADDAC(a[37], a[42]); SQRADDAC(a[38], a[41]); SQRADDAC(a[39], a[40]); SQRADDDB; + COMBA_STORE(b[79]); + + /* output 80 */ + CARRY_FORWARD; + SQRADDSC(a[33], a[47]); SQRADDAC(a[34], a[46]); SQRADDAC(a[35], a[45]); SQRADDAC(a[36], a[44]); SQRADDAC(a[37], a[43]); SQRADDAC(a[38], a[42]); SQRADDAC(a[39], a[41]); SQRADDDB; SQRADD(a[40], a[40]); + COMBA_STORE(b[80]); + + /* output 81 */ + CARRY_FORWARD; + SQRADDSC(a[34], a[47]); SQRADDAC(a[35], a[46]); SQRADDAC(a[36], a[45]); SQRADDAC(a[37], a[44]); SQRADDAC(a[38], a[43]); SQRADDAC(a[39], a[42]); SQRADDAC(a[40], a[41]); SQRADDDB; + COMBA_STORE(b[81]); + + /* output 82 */ + CARRY_FORWARD; + SQRADDSC(a[35], a[47]); SQRADDAC(a[36], a[46]); SQRADDAC(a[37], a[45]); SQRADDAC(a[38], a[44]); SQRADDAC(a[39], a[43]); SQRADDAC(a[40], a[42]); SQRADDDB; SQRADD(a[41], a[41]); + COMBA_STORE(b[82]); + + /* output 83 */ + CARRY_FORWARD; + SQRADDSC(a[36], a[47]); SQRADDAC(a[37], a[46]); SQRADDAC(a[38], a[45]); SQRADDAC(a[39], a[44]); SQRADDAC(a[40], a[43]); SQRADDAC(a[41], a[42]); SQRADDDB; + COMBA_STORE(b[83]); + + /* output 84 */ + CARRY_FORWARD; + SQRADDSC(a[37], a[47]); SQRADDAC(a[38], a[46]); SQRADDAC(a[39], a[45]); SQRADDAC(a[40], a[44]); SQRADDAC(a[41], a[43]); SQRADDDB; SQRADD(a[42], a[42]); + COMBA_STORE(b[84]); + + /* output 85 */ + CARRY_FORWARD; + SQRADDSC(a[38], a[47]); SQRADDAC(a[39], a[46]); SQRADDAC(a[40], a[45]); SQRADDAC(a[41], a[44]); SQRADDAC(a[42], a[43]); SQRADDDB; + COMBA_STORE(b[85]); + + /* output 86 */ + CARRY_FORWARD; + SQRADDSC(a[39], a[47]); SQRADDAC(a[40], a[46]); SQRADDAC(a[41], a[45]); SQRADDAC(a[42], a[44]); SQRADDDB; SQRADD(a[43], a[43]); + COMBA_STORE(b[86]); + + /* output 87 */ + CARRY_FORWARD; + SQRADDSC(a[40], a[47]); SQRADDAC(a[41], a[46]); SQRADDAC(a[42], a[45]); SQRADDAC(a[43], a[44]); SQRADDDB; + COMBA_STORE(b[87]); + + /* output 88 */ + CARRY_FORWARD; + SQRADDSC(a[41], a[47]); SQRADDAC(a[42], a[46]); SQRADDAC(a[43], a[45]); SQRADDDB; SQRADD(a[44], a[44]); + COMBA_STORE(b[88]); + + /* output 89 */ + CARRY_FORWARD; + SQRADDSC(a[42], a[47]); SQRADDAC(a[43], a[46]); SQRADDAC(a[44], a[45]); SQRADDDB; + COMBA_STORE(b[89]); + + /* output 90 */ + CARRY_FORWARD; + SQRADD2(a[43], a[47]); SQRADD2(a[44], a[46]); SQRADD(a[45], a[45]); + COMBA_STORE(b[90]); + + /* output 91 */ + CARRY_FORWARD; + SQRADD2(a[44], a[47]); SQRADD2(a[45], a[46]); + COMBA_STORE(b[91]); + + /* output 92 */ + CARRY_FORWARD; + SQRADD2(a[45], a[47]); SQRADD(a[46], a[46]); + COMBA_STORE(b[92]); + + /* output 93 */ + CARRY_FORWARD; + SQRADD2(a[46], a[47]); + COMBA_STORE(b[93]); + + /* output 94 */ + CARRY_FORWARD; + SQRADD(a[47], a[47]); + COMBA_STORE(b[94]); + COMBA_STORE2(b[95]); + COMBA_FINI; + + B->used = 96; + B->sign = FP_ZPOS; + memcpy(B->dp, b, 96 * sizeof(fp_digit)); + fp_clamp(B); +} + #endif +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + + /* End: fp_sqr_comba.c */ /* Start: fp_sqr_comba_generic.c */ +/* 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@gmail.com + */ + /* generic comba squarer */ void fp_sqr_comba(fp_int *A, fp_int *B) { @@ -5152,6 +9165,10 @@ void fp_sqr_comba(fp_int *A, fp_int *B) } } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_sqr_comba_generic.c */ /* Start: fp_sqrmod.c */ @@ -5162,7 +9179,7 @@ void fp_sqr_comba(fp_int *A, fp_int *B) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5175,6 +9192,10 @@ int fp_sqrmod(fp_int *a, fp_int *b, fp_int *c) return fp_mod(&tmp, b, c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_sqrmod.c */ /* Start: fp_sub.c */ @@ -5185,7 +9206,7 @@ int fp_sqrmod(fp_int *a, fp_int *b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5225,6 +9246,10 @@ void fp_sub(fp_int *a, fp_int *b, fp_int *c) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_sub.c */ /* Start: fp_sub_d.c */ @@ -5235,7 +9260,7 @@ void fp_sub(fp_int *a, fp_int *b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5247,6 +9272,10 @@ void fp_sub_d(fp_int *a, fp_digit b, fp_int *c) fp_sub(a, &tmp, c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_sub_d.c */ /* Start: fp_submod.c */ @@ -5257,7 +9286,7 @@ void fp_sub_d(fp_int *a, fp_digit b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5271,6 +9300,10 @@ int fp_submod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_submod.c */ /* Start: fp_to_signed_bin.c */ @@ -5281,7 +9314,7 @@ int fp_submod(fp_int *a, fp_int *b, fp_int *c, fp_int *d) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5291,6 +9324,10 @@ void fp_to_signed_bin(fp_int *a, unsigned char *b) b[0] = (unsigned char) ((a->sign == FP_ZPOS) ? 0 : 1); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_to_signed_bin.c */ /* Start: fp_to_unsigned_bin.c */ @@ -5301,7 +9338,7 @@ void fp_to_signed_bin(fp_int *a, unsigned char *b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5320,6 +9357,10 @@ void fp_to_unsigned_bin(fp_int *a, unsigned char *b) bn_reverse (b, x); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_to_unsigned_bin.c */ /* Start: fp_toradix.c */ @@ -5330,7 +9371,7 @@ void fp_to_unsigned_bin(fp_int *a, unsigned char *b) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5379,6 +9420,10 @@ int fp_toradix(fp_int *a, char *str, int radix) return FP_OKAY; } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_toradix.c */ /* Start: fp_unsigned_bin_size.c */ @@ -5389,7 +9434,7 @@ int fp_toradix(fp_int *a, char *str, int radix) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5399,6 +9444,10 @@ int fp_unsigned_bin_size(fp_int *a) return (size / 8 + ((size & 7) != 0 ? 1 : 0)); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: fp_unsigned_bin_size.c */ /* Start: s_fp_add.c */ @@ -5409,7 +9458,7 @@ int fp_unsigned_bin_size(fp_int *a) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5440,6 +9489,10 @@ void s_fp_add(fp_int *a, fp_int *b, fp_int *c) fp_clamp(c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: s_fp_add.c */ /* Start: s_fp_sub.c */ @@ -5450,7 +9503,7 @@ void s_fp_add(fp_int *a, fp_int *b, fp_int *c) * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -5475,6 +9528,10 @@ void s_fp_sub(fp_int *a, fp_int *b, fp_int *c) fp_clamp(c); } +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ + /* End: s_fp_sub.c */ diff --git a/s_fp_add.c b/s_fp_add.c index e0f10f6..3a874f2 100644 --- a/s_fp_add.c +++ b/s_fp_add.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -35,3 +35,7 @@ void s_fp_add(fp_int *a, fp_int *b, fp_int *c) } fp_clamp(c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/s_fp_sub.c b/s_fp_sub.c index de5546c..41cc6c4 100644 --- a/s_fp_sub.c +++ b/s_fp_sub.c @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #include @@ -29,3 +29,7 @@ void s_fp_sub(fp_int *a, fp_int *b, fp_int *c) } fp_clamp(c); } + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/tfm.aux b/tfm.aux new file mode 100644 index 0000000..865325f --- /dev/null +++ b/tfm.aux @@ -0,0 +1,56 @@ +\relax +\ifx\hyper@anchor\@undefined +\global \let \oldcontentsline\contentsline +\gdef \contentsline#1#2#3#4{\oldcontentsline{#1}{#2}{#3}} +\global \let \oldnewlabel\newlabel +\gdef \newlabel#1#2{\newlabelxx{#1}#2} +\gdef \newlabelxx#1#2#3#4#5#6{\oldnewlabel{#1}{{#2}{#3}}} +\AtEndDocument{\let \contentsline\oldcontentsline +\let \newlabel\oldnewlabel} +\else +\global \let \hyper@last\relax +\fi + +\@writefile{toc}{\contentsline {chapter}{\numberline {1}Introduction}{1}{chapter.1}} +\@writefile{lof}{\addvspace {10\p@ }} +\@writefile{lot}{\addvspace {10\p@ }} +\@writefile{toc}{\contentsline {section}{\numberline {1.1}What is TomsFastMath?}{1}{section.1.1}} +\@writefile{toc}{\contentsline {section}{\numberline {1.2}License}{2}{section.1.2}} +\@writefile{toc}{\contentsline {section}{\numberline {1.3}Building}{2}{section.1.3}} +\@writefile{toc}{\contentsline {subsection}{\numberline {1.3.1}Build Limitations}{2}{subsection.1.3.1}} +\@writefile{toc}{\contentsline {subsection}{\numberline {1.3.2}Optimization Configuration}{2}{subsection.1.3.2}} +\@writefile{toc}{\contentsline {subsubsection}{x86--32}{3}{section*.3}} +\@writefile{toc}{\contentsline {subsubsection}{SSE2}{3}{section*.4}} +\@writefile{toc}{\contentsline {subsubsection}{x86--64}{3}{section*.5}} +\@writefile{toc}{\contentsline {subsubsection}{ARM}{3}{section*.6}} +\@writefile{toc}{\contentsline {subsubsection}{PPC32}{3}{section*.7}} +\@writefile{toc}{\contentsline {subsubsection}{Future Releases}{4}{section*.8}} +\@writefile{lof}{\contentsline {figure}{\numberline {1.1}{\ignorespaces Recommended Build Modes}}{4}{figure.1.1}} +\@writefile{toc}{\contentsline {subsection}{\numberline {1.3.3}Precision Configuration}{4}{subsection.1.3.3}} +\@writefile{toc}{\contentsline {chapter}{\numberline {2}Getting Started}{5}{chapter.2}} +\@writefile{lof}{\addvspace {10\p@ }} +\@writefile{lot}{\addvspace {10\p@ }} +\@writefile{toc}{\contentsline {section}{\numberline {2.1}Data Types}{5}{section.2.1}} +\@writefile{toc}{\contentsline {section}{\numberline {2.2}Initialization}{6}{section.2.2}} +\@writefile{toc}{\contentsline {subsection}{\numberline {2.2.1}Simple Initialization}{6}{subsection.2.2.1}} +\@writefile{toc}{\contentsline {subsection}{\numberline {2.2.2}Initialize Small Constants}{6}{subsection.2.2.2}} +\@writefile{toc}{\contentsline {subsection}{\numberline {2.2.3}Initialize Copy}{6}{subsection.2.2.3}} +\@writefile{toc}{\contentsline {chapter}{\numberline {3}Arithmetic Operations}{7}{chapter.3}} +\@writefile{lof}{\addvspace {10\p@ }} +\@writefile{lot}{\addvspace {10\p@ }} +\@writefile{toc}{\contentsline {section}{\numberline {3.1}Odds and Evens}{7}{section.3.1}} +\@writefile{toc}{\contentsline {section}{\numberline {3.2}Sign Manipulation}{7}{section.3.2}} +\@writefile{toc}{\contentsline {section}{\numberline {3.3}Comparisons}{8}{section.3.3}} +\@writefile{toc}{\contentsline {section}{\numberline {3.4}Shifting}{8}{section.3.4}} +\@writefile{toc}{\contentsline {section}{\numberline {3.5}Basic Algebra}{9}{section.3.5}} +\@writefile{toc}{\contentsline {section}{\numberline {3.6}Modular Exponentiation}{9}{section.3.6}} +\@writefile{toc}{\contentsline {section}{\numberline {3.7}Number Theoretic}{9}{section.3.7}} +\@writefile{toc}{\contentsline {section}{\numberline {3.8}Prime Numbers}{10}{section.3.8}} +\@writefile{toc}{\contentsline {chapter}{\numberline {4}Porting TomsFastMath}{11}{chapter.4}} +\@writefile{lof}{\addvspace {10\p@ }} +\@writefile{lot}{\addvspace {10\p@ }} +\newlabel{chap:asmops}{{4}{11}{Porting TomsFastMath\relax }{chapter.4}{}} +\@writefile{toc}{\contentsline {section}{\numberline {4.1}Getting Started}{11}{section.4.1}} +\@writefile{toc}{\contentsline {section}{\numberline {4.2}Multiply with Comba}{11}{section.4.2}} +\@writefile{toc}{\contentsline {section}{\numberline {4.3}Squaring with Comba}{13}{section.4.3}} +\@writefile{toc}{\contentsline {section}{\numberline {4.4}Montgomery with Comba}{15}{section.4.4}} diff --git a/tfm.dvi b/tfm.dvi new file mode 100644 index 0000000000000000000000000000000000000000..d1c36300cafa5ff2539522996a2c9207ead65c45 GIT binary patch literal 49708 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 #include -#undef MIN -#define MIN(x,y) ((x)<(y)?(x):(y)) -#undef MAX -#define MAX(x,y) ((x)>(y)?(x):(y)) +#ifndef MIN + #define MIN(x,y) ((x)<(y)?(x):(y)) +#endif -/* do we want large code? */ -#define TFM_LARGE +#ifndef MAX + #define MAX(x,y) ((x)>(y)?(x):(y)) +#endif -/* do we want huge code (implies large)? The answer is, yes. */ +/* externally define this symbol to ignore the default settings, useful for changing the build from the make process */ +#ifndef TFM_ALREADY_SET + +/* do we want the large set of small multiplications ? + Enable these if you are going to be doing a lot of small (<= 16 digit) multiplications say in ECC + Or if you're on a 64-bit machine doing RSA as a 1024-bit integer == 16 digits ;-) + */ +#define TFM_SMALL_SET + +/* do we want huge code + Enable these if you are doing 32, 48 or 64 digit multiplications (useful for RSA) + Less important on 64-bit machines as 32 digits == 2048 bits + */ #define TFM_HUGE -/* imply TFM_LARGE as required */ -#if defined(TFM_HUGE) - #if !defined(TFM_LARGE) - #define TFM_LARGE - #endif +/* do we want some overflow checks + Not required if you make sure your numbers are within range (e.g. by default a modulus for fp_exptmod() can only be upto 2048 bits long) + */ +/* #define TFM_CHECK */ + +/* Is the target a P4 Prescott + */ +/* #define TFM_PRESCOTT */ + #endif /* Max size of any number in bits. Basically the largest size you will be multiplying * should be half [or smaller] of FP_MAX_SIZE-four_digit * - * You can externally define this or it defaults to 4096-bits. + * You can externally define this or it defaults to 4096-bits [allowing multiplications upto 2048x2048 bits ] */ #ifndef FP_MAX_SIZE #define FP_MAX_SIZE (4096+(4*DIGIT_BIT)) @@ -76,9 +92,9 @@ #endif #endif -/* make sure we're 32-bit for x86-32/sse/arm */ -#if (defined(TFM_X86) || defined(TFM_SSE2) || defined(TFM_ARM)) && defined(FP_64BIT) - #warning x86-32, SSE2 and ARM optimizations require 32-bit digits (undefining) +/* make sure we're 32-bit for x86-32/sse/arm/ppc32 */ +#if (defined(TFM_X86) || defined(TFM_SSE2) || defined(TFM_ARM) || defined(TFM_PPC32)) && defined(FP_64BIT) + #warning x86-32, SSE2 and ARM, PPC32 optimizations require 32-bit digits (undefining) #undef FP_64BIT #endif @@ -104,6 +120,12 @@ #endif #define TFM_ASM #endif +#ifdef TFM_PPC32 + #ifdef TFM_ASM + #error TFM_ASM already defined! + #endif + #define TFM_ASM +#endif /* we want no asm? */ #ifdef TFM_NO_ASM @@ -111,6 +133,7 @@ #undef TFM_X86_64 #undef TFM_SSE2 #undef TFM_ARM + #undef TFM_PPC32 #undef TFM_ASM #endif @@ -179,8 +202,8 @@ const char *fp_ident(void); /* zero/even/odd ? */ #define fp_iszero(a) (((a)->used == 0) ? FP_YES : FP_NO) -#define fp_iseven(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? FP_YES : FP_NO) -#define fp_isodd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? FP_YES : FP_NO) +#define fp_iseven(a) (((a)->used >= 0 && (((a)->dp[0] & 1) == 0)) ? FP_YES : FP_NO) +#define fp_isodd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? FP_YES : FP_NO) /* set to a small digit */ void fp_set(fp_int *a, fp_digit b); @@ -335,24 +358,22 @@ void bn_reverse(unsigned char *s, int len); void fp_mul_comba(fp_int *A, fp_int *B, fp_int *C); #ifdef TFM_HUGE void fp_mul_comba32(fp_int *A, fp_int *B, fp_int *C); +void fp_mul_comba48(fp_int *A, fp_int *B, fp_int *C); +void fp_mul_comba64(fp_int *A, fp_int *B, fp_int *C); #endif -#ifdef TFM_LARGE -void fp_mul_comba16(fp_int *A, fp_int *B, fp_int *C); -#endif -void fp_mul_comba8(fp_int *A, fp_int *B, fp_int *C); -void fp_mul_comba4(fp_int *A, fp_int *B, fp_int *C); +void fp_mul_comba_small(fp_int *A, fp_int *B, fp_int *C); -void fp_sqr_comba(fp_int *A, fp_int *B); -void fp_sqr_comba4(fp_int *A, fp_int *B); -void fp_sqr_comba8(fp_int *A, fp_int *B); -#ifdef TFM_LARGE -void fp_sqr_comba16(fp_int *A, fp_int *B); -#endif +void fp_sqr_comba_small(fp_int *A, fp_int *B); #ifdef TFM_HUGE void fp_sqr_comba32(fp_int *A, fp_int *B); +void fp_sqr_comba48(fp_int *A, fp_int *B); void fp_sqr_comba64(fp_int *A, fp_int *B); #endif extern const char *fp_s_rmap; #endif + +/* $Source$ */ +/* $Revision$ */ +/* $Date$ */ diff --git a/tfm.idx b/tfm.idx new file mode 100644 index 0000000..65f1bf8 --- /dev/null +++ b/tfm.idx @@ -0,0 +1,29 @@ +\indexentry{fp\_init|hyperpage}{6} +\indexentry{fp\_set|hyperpage}{6} +\indexentry{fp\_init\_copy|hyperpage}{6} +\indexentry{fp\_iszero|hyperpage}{7} +\indexentry{fp\_iseven|hyperpage}{7} +\indexentry{fp\_isodd|hyperpage}{7} +\indexentry{fp\_neg|hyperpage}{7} +\indexentry{fp\_abs|hyperpage}{7} +\indexentry{fp\_cmp|hyperpage}{8} +\indexentry{fp\_cmp\_mag|hyperpage}{8} +\indexentry{fp\_lshd|hyperpage}{8} +\indexentry{fp\_rshd|hyperpage}{8} +\indexentry{fp\_div\_2d|hyperpage}{8} +\indexentry{fp\_mod\_2d|hyperpage}{8} +\indexentry{fp\_mul\_2d|hyperpage}{8} +\indexentry{fp\_div\_2|hyperpage}{8} +\indexentry{fp\_mul\_2|hyperpage}{8} +\indexentry{fp\_cnt\_lsb|hyperpage}{8} +\indexentry{fp\_add|hyperpage}{9} +\indexentry{fp\_sub|hyperpage}{9} +\indexentry{fp\_mul|hyperpage}{9} +\indexentry{fp\_sqr|hyperpage}{9} +\indexentry{fp\_div|hyperpage}{9} +\indexentry{fp\_mod|hyperpage}{9} +\indexentry{fp\_exptmod|hyperpage}{9} +\indexentry{fp\_invmod|hyperpage}{9} +\indexentry{fp\_gcd|hyperpage}{9} +\indexentry{fp\_lcm|hyperpage}{9} +\indexentry{fp\_isprime|hyperpage}{10} diff --git a/tfm.ilg b/tfm.ilg new file mode 100644 index 0000000..cf7dd87 --- /dev/null +++ b/tfm.ilg @@ -0,0 +1,6 @@ +This is makeindex, version 2.14 [02-Oct-2002] (kpathsea + Thai support). +Scanning input file tfm.idx....done (29 entries accepted, 0 rejected). +Sorting entries....done (137 comparisons). +Generating output file tfm.ind....done (33 lines written, 0 warnings). +Output written in tfm.ind. +Transcript written in tfm.ilg. diff --git a/tfm.ind b/tfm.ind new file mode 100644 index 0000000..a2a2a57 --- /dev/null +++ b/tfm.ind @@ -0,0 +1,33 @@ +\begin{theindex} + + \item fp\_abs, \hyperpage{7} + \item fp\_add, \hyperpage{9} + \item fp\_cmp, \hyperpage{8} + \item fp\_cmp\_mag, \hyperpage{8} + \item fp\_cnt\_lsb, \hyperpage{8} + \item fp\_div, \hyperpage{9} + \item fp\_div\_2, \hyperpage{8} + \item fp\_div\_2d, \hyperpage{8} + \item fp\_exptmod, \hyperpage{9} + \item fp\_gcd, \hyperpage{9} + \item fp\_init, \hyperpage{6} + \item fp\_init\_copy, \hyperpage{6} + \item fp\_invmod, \hyperpage{9} + \item fp\_iseven, \hyperpage{7} + \item fp\_isodd, \hyperpage{7} + \item fp\_isprime, \hyperpage{10} + \item fp\_iszero, \hyperpage{7} + \item fp\_lcm, \hyperpage{9} + \item fp\_lshd, \hyperpage{8} + \item fp\_mod, \hyperpage{9} + \item fp\_mod\_2d, \hyperpage{8} + \item fp\_mul, \hyperpage{9} + \item fp\_mul\_2, \hyperpage{8} + \item fp\_mul\_2d, \hyperpage{8} + \item fp\_neg, \hyperpage{7} + \item fp\_rshd, \hyperpage{8} + \item fp\_set, \hyperpage{6} + \item fp\_sqr, \hyperpage{9} + \item fp\_sub, \hyperpage{9} + +\end{theindex} diff --git a/tfm.lof b/tfm.lof new file mode 100644 index 0000000..370c50c --- /dev/null +++ b/tfm.lof @@ -0,0 +1,5 @@ +\addvspace {10\p@ } +\contentsline {figure}{\numberline {1.1}{\ignorespaces Recommended Build Modes}}{4}{figure.1.1} +\addvspace {10\p@ } +\addvspace {10\p@ } +\addvspace {10\p@ } diff --git a/tfm.log b/tfm.log new file mode 100644 index 0000000..d46bd4a --- /dev/null +++ b/tfm.log @@ -0,0 +1,332 @@ +This is pdfeTeX, Version 3.141592-1.21a-2.2 (Web2C 7.5.4) (format=latex 2005.4.10) 23 JUL 2005 07:42 +entering extended mode +**tfm +(./tfm.tex +LaTeX2e <2003/12/01> +Babel and hyphenation patterns for american, french, german, ngerman, b +ahasa, basque, bulgarian, catalan, croatian, czech, danish, dutch, esperanto, e +stonian, finnish, greek, icelandic, irish, italian, latin, magyar, norsk, polis +h, portuges, romanian, russian, serbian, slovak, slovene, spanish, swedish, tur +kish, ukrainian, nohyphenation, loaded. +(/usr/share/texmf/tex/latex/base/book.cls +Document Class: book 2004/02/16 v1.4f Standard LaTeX document class +(/usr/share/texmf/tex/latex/base/bk10.clo +File: bk10.clo 2004/02/16 v1.4f Standard LaTeX file (size option) +) +\c@part=\count79 +\c@chapter=\count80 +\c@section=\count81 +\c@subsection=\count82 +\c@subsubsection=\count83 +\c@paragraph=\count84 +\c@subparagraph=\count85 +\c@figure=\count86 +\c@table=\count87 +\abovecaptionskip=\skip41 +\belowcaptionskip=\skip42 +\bibindent=\dimen102 +) +(/usr/share/texmf/tex/latex/hyperref/hyperref.sty +Package: hyperref 2003/11/30 v6.74m Hypertext links for LaTeX + +(/usr/share/texmf/tex/latex/graphics/keyval.sty +Package: keyval 1999/03/16 v1.13 key=value parser (DPC) +\KV@toks@=\toks14 +) +\@linkdim=\dimen103 +\Hy@linkcounter=\count88 +\Hy@pagecounter=\count89 + +(/usr/share/texmf/tex/latex/hyperref/pd1enc.def +File: pd1enc.def 2003/11/30 v6.74m Hyperref: PDFDocEncoding definition (HO) +) +(/usr/share/texmf/tex/latex/hyperref/hyperref.cfg +File: hyperref.cfg 2002/06/06 v1.2 hyperref configuration of TeXLive and teTeX +) +Package hyperref Info: Hyper figures OFF on input line 1880. +Package hyperref Info: Link nesting OFF on input line 1885. +Package hyperref Info: Hyper index ON on input line 1888. +Package hyperref Info: Plain pages ON on input line 1893. +Package hyperref Info: Backreferencing OFF on input line 1900. + +Implicit mode ON; LaTeX internals redefined +Package hyperref Info: Bookmarks ON on input line 2004. +(/usr/share/texmf/tex/latex/html/url.sty +Package: url 1999/03/02 ver 1.4 Verb mode for urls, email addresses, and file + names +) +LaTeX Info: Redefining \url on input line 2143. +\Fld@menulength=\count90 +\Field@Width=\dimen104 +\Fld@charsize=\dimen105 +\Choice@toks=\toks15 +\Field@toks=\toks16 +Package hyperref Info: Hyper figures OFF on input line 2618. +Package hyperref Info: Link nesting OFF on input line 2623. +Package hyperref Info: Hyper index ON on input line 2626. +Package hyperref Info: backreferencing OFF on input line 2633. +Package hyperref Info: Link coloring OFF on input line 2638. +\c@Item=\count91 +\c@Hfootnote=\count92 +) +*hyperref using default driver hypertex* +(/usr/share/texmf/tex/latex/hyperref/hypertex.def +File: hypertex.def 2003/11/30 v6.74m Hyperref driver for HyperTeX specials +) +(/usr/share/texmf/tex/latex/base/makeidx.sty +Package: makeidx 2000/03/29 v1.0m Standard LaTeX package +) +(/usr/share/texmf/tex/latex/amsfonts/amssymb.sty +Package: amssymb 2002/01/22 v2.2d + +(/usr/share/texmf/tex/latex/amsfonts/amsfonts.sty +Package: amsfonts 2001/10/25 v2.2f +\@emptytoks=\toks17 +\symAMSa=\mathgroup4 +\symAMSb=\mathgroup5 +LaTeX Font Info: Overwriting math alphabet `\mathfrak' in version `bold' +(Font) U/euf/m/n --> U/euf/b/n on input line 132. +)) +(/usr/share/texmf/tex/latex/graphics/color.sty +Package: color 1999/02/16 v1.0i Standard LaTeX Color (DPC) + +(/usr/share/texmf/tex/latex/graphics/color.cfg +File: color.cfg 2005/02/03 v1.3 color configuration of teTeX/TeXLive +) +Package color Info: Driver file: dvips.def on input line 125. + +(/usr/share/texmf/tex/latex/graphics/dvips.def +File: dvips.def 1999/02/16 v3.0i Driver-dependant file (DPC,SPQR) +) +(/usr/share/texmf/tex/latex/graphics/dvipsnam.def +File: dvipsnam.def 1999/02/16 v3.0i Driver-dependant file (DPC,SPQR) +)) +(/usr/share/texmf/tex/latex/base/alltt.sty +Package: alltt 1997/06/16 v2.0g defines alltt environment +) +(/usr/share/texmf/tex/latex/graphics/graphicx.sty +Package: graphicx 1999/02/16 v1.0f Enhanced LaTeX Graphics (DPC,SPQR) + +(/usr/share/texmf/tex/latex/graphics/graphics.sty +Package: graphics 2001/07/07 v1.0n Standard LaTeX Graphics (DPC,SPQR) + +(/usr/share/texmf/tex/latex/graphics/trig.sty +Package: trig 1999/03/16 v1.09 sin cos tan (DPC) +) +(/usr/share/texmf/tex/latex/graphics/graphics.cfg +File: graphics.cfg 2005/02/03 v1.3 graphics configuration of teTeX/TeXLive +) +Package graphics Info: Driver file: dvips.def on input line 80. +) +\Gin@req@height=\dimen106 +\Gin@req@width=\dimen107 +) +(/usr/share/texmf/tex/latex/tools/layout.sty +Package: layout 2000/09/25 v1.2c Show layout parameters +\oneinch=\count93 +\cnt@paperwidth=\count94 +\cnt@paperheight=\count95 +\cnt@hoffset=\count96 +\cnt@voffset=\count97 +\cnt@textheight=\count98 +\cnt@textwidth=\count99 +\cnt@topmargin=\count100 +\cnt@oddsidemargin=\count101 +\cnt@evensidemargin=\count102 +\cnt@headheight=\count103 +\cnt@headsep=\count104 +\cnt@marginparsep=\count105 +\cnt@marginparwidth=\count106 +\cnt@marginparpush=\count107 +\cnt@footskip=\count108 +\fheight=\count109 +\ref@top=\count110 +\ref@hoffset=\count111 +\ref@voffset=\count112 +\ref@head=\count113 +\ref@body=\count114 +\ref@foot=\count115 +\ref@margin=\count116 +\ref@marginwidth=\count117 +\ref@marginpar=\count118 +\Interval=\count119 +\ExtraYPos=\count120 +\PositionX=\count121 +\PositionY=\count122 +\ArrowLength=\count123 +) +\@indexfile=\write3 +\openout3 = `tfm.idx'. + + +Writing index file tfm.idx +(./tfm.aux) +\openout1 = `tfm.aux'. + +LaTeX Font Info: Checking defaults for OML/cmm/m/it on input line 49. +LaTeX Font Info: ... okay on input line 49. +LaTeX Font Info: Checking defaults for T1/cmr/m/n on input line 49. +LaTeX Font Info: ... okay on input line 49. +LaTeX Font Info: Checking defaults for OT1/cmr/m/n on input line 49. +LaTeX Font Info: ... okay on input line 49. +LaTeX Font Info: Checking defaults for OMS/cmsy/m/n on input line 49. +LaTeX Font Info: ... okay on input line 49. +LaTeX Font Info: Checking defaults for OMX/cmex/m/n on input line 49. +LaTeX Font Info: ... okay on input line 49. +LaTeX Font Info: Checking defaults for U/cmr/m/n on input line 49. +LaTeX Font Info: ... okay on input line 49. +LaTeX Font Info: Checking defaults for PD1/pdf/m/n on input line 49. +LaTeX Font Info: ... okay on input line 49. +Package hyperref Info: Link coloring OFF on input line 49. + (/usr/share/texmf/tex/latex/hyperref/nameref.sty +Package: nameref 2003/12/03 v2.21 Cross-referencing by name of section +\c@section@level=\count124 +) +LaTeX Info: Redefining \ref on input line 49. +LaTeX Info: Redefining \pageref on input line 49. +LaTeX Font Info: Try loading font information for U+msa on input line 55. + +(/usr/share/texmf/tex/latex/amsfonts/umsa.fd +File: umsa.fd 2002/01/19 v2.2g AMS font definitions +) +LaTeX Font Info: Try loading font information for U+msb on input line 55. + +(/usr/share/texmf/tex/latex/amsfonts/umsb.fd +File: umsb.fd 2002/01/19 v2.2g AMS font definitions +) [1 + + + +] [2] (./tfm.toc [3 + +]) +\tf@toc=\write4 +\openout4 = `tfm.toc'. + + [4] +(./tfm.lof) +\tf@lof=\write5 +\openout5 = `tfm.lof'. + + [5 + +] [6 + +] +Chapter 1. +[1 + +] [2] [3] [4] +Chapter 2. + +Underfull \vbox (badness 7649) has occurred while \output is active [] + + [5 + +] +[6] +Chapter 3. +[7 + +] [8] [9] [10] +Chapter 4. +[11 + +] [12] [13] +Overfull \hbox (74.99634pt too wide) in paragraph at lines 547--547 +[]\OT1/cmtt/m/n/10 #define SQRADDSC(i, j) + \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 547--547 +[] \OT1/cmtt/m/n/10 do { fp_word t; + \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 547--547 +[] \OT1/cmtt/m/n/10 t = ((fp_word)i) * ((fp_word)j); + \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 547--547 +[] \OT1/cmtt/m/n/10 sc0 = (fp_digit)t; sc1 = (t >> DIGIT_BIT); sc2 = 0; + \[] + [] + + +Overfull \hbox (25.129pt too wide) in paragraph at lines 548--549 +\OT1/cmr/m/n/10 This com-putes a prod-uct and stores it in the ``sec-ondary'' c +arry reg-is-ters $[]$. + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 556--556 +[]\OT1/cmtt/m/n/10 #define SQRADDAC(i, j) + \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 556--556 +[] \OT1/cmtt/m/n/10 do { fp_word t; + \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 556--556 +[] \OT1/cmtt/m/n/10 t = sc0 + ((fp_word)i) * ((fp_word)j); sc0 = t; + \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 556--556 +[] \OT1/cmtt/m/n/10 t = sc1 + (t >> DIGIT_BIT); sc1 = t; sc2 += t + >> DIGIT_BIT; \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 566--566 +[]\OT1/cmtt/m/n/10 #define SQRADDDB + \[] + [] + + +Overfull \hbox (74.99634pt too wide) in paragraph at lines 566--566 +[] \OT1/cmtt/m/n/10 do { fp_word t; + \[] + [] + + +Overfull \hbox (190.49533pt too wide) in paragraph at lines 566--566 +[] \OT1/cmtt/m/n/10 t = ((fp_word)sc0) + ((fp_word)sc0) + c0; c0 = t; + \[] + [] + + +Overfull \hbox (190.49533pt too wide) in paragraph at lines 566--566 +[] \OT1/cmtt/m/n/10 t = ((fp_word)sc1) + ((fp_word)sc1) + c1 + (t >> DIGIT_BI +T); c1 = t; \[] + [] + + +Overfull \hbox (190.49533pt too wide) in paragraph at lines 566--566 +[] \OT1/cmtt/m/n/10 c2 = c2 + ((fp_word)sc2) + ((fp_word)sc2) + (t >> DIGIT_B +IT); \[] + [] + +[14] [15] (./tfm.ind [16] [17 + + +]) (./tfm.aux) ) +Here is how much of TeX's memory you used: + 2712 strings out of 49501 + 35892 string characters out of 426789 + 81342 words of memory out of 1100000 + 5856 multiletter control sequences out of 10000+15000 + 15453 words of font info for 59 fonts, out of 400000 for 2000 + 580 hyphenation exceptions out of 1000 + 25i,9n,25p,195b,321s stack positions out of 1500i,500n,1500p,200000b,5000s + +Output written on tfm.dvi (23 pages, 49708 bytes). diff --git a/tfm.tex b/tfm.tex index f99d53e..08d7bfb 100644 --- a/tfm.tex +++ b/tfm.tex @@ -49,7 +49,7 @@ \begin{document} \frontmatter \pagestyle{empty} -\title{TomsFastMath User Manual \\ v0.03} +\title{TomsFastMath User Manual \\ v0.04} \author{Tom St Denis \\ tomstdenis@iahu.ca} \maketitle This text and library are all hereby placed in the public domain. This book has been formatted for B5 @@ -143,6 +143,10 @@ TFM\_X86 and TFM\_SSE2 at the same time. This mode only works with 32--bit dig mode fp\_digit is 32--bits and fp\_word is 64--bits. While this mode will work on the AMD Athlon64 series of processors it is less efficient than the native ``x86--64'' mode and not recommended. +There is an additional ``TFM\_PRESCOTT'' flag that you can define for P4 Prescott processors. This causes +the mul/sqr functions to use x86\_32 and the montgomery reduction to use SSE2 which is (so far) the fastest +combination. If you are using an older (e.g. Northwood) generation P4 don't define this. + \subsubsection{x86--64} The ``x86--64'' mode is defined by ``TFM\_X86\_64'' and requires a ``x86--64'' capable processor (Athlon64 and future Pentium processors). It requires GCC to build and only works with 64--bit digits. Note that by enabling this mode it will automatically @@ -150,12 +154,16 @@ enable 64--bit digits. In this mode fp\_digit is 64--bits and fp\_word is 128-- be autodetected when building with GCC to an ``x86--64'' target. You can override this behaviour by defining TFM\_NO\_ASM. -\subsubsection{ARM} The ``ARM'' mode is defined by ``TFM\_ARM'' and requires a ARMv4 or higher -processor. It requires GCC and works with 32--bit digits. In this mode fp\_digit is 32--bits and +\subsubsection{ARM} The ``ARM'' mode is defined by ``TFM\_ARM'' and requires a ARMv4 with the M instructions (enhanced +multipliers) or higher processor. It requires GCC and works with 32--bit digits. In this mode fp\_digit is 32--bits and fp\_word is 64--bits. +\subsubsection{PPC32} The ``PPC32'' mode is defined by ``TFM\_PPC32'' and requires a standard PPC processor. It doesn't +use altivec or other extensions so it should work on all compliant implementations of PPC. It requires GCC and works +with 32--bit digits. In this mode fp\_digit is 32--bits and fp\_word is 64--bits. + \subsubsection{Future Releases} Future releases will support additional platform optimizations. -Developers of MIPS and PPC platforms are encouraged to submit GCC asm inline patches +Developers of MIPS and SPARC platforms are encouraged to submit GCC asm inline patches (see chapter \ref{chap:asmops} for more information). \begin{figure}[here] @@ -165,8 +173,10 @@ Developers of MIPS and PPC platforms are encouraged to submit GCC asm inline pat \hline \textbf{Processor} & \textbf{Recommended Mode} \\ \hline All 32--bit x86 platforms & TFM\_X86 \\ \hline Pentium 4 & TFM\_SSE2 \\ +\hline Pentium 4 Prescott & TFM\_SSE2 + TFM\_PRESCOTT \\ \hline Athlon64 & TFM\_X86\_64 \\ -\hline ARMv4 or higher & TFM\_ARM \\ +\hline ARMv4 or higher with M & TFM\_ARM \\ +\hline G3/G4 (32-bit PPC) & TFM\_PPC32 \\ \hline &\\ \hline x86--32 or x86--64 (with GCC) & Leave blank and let autodetect work \\ \hline @@ -589,26 +599,26 @@ This computes the $\mu$ value for the inner loop. You can safely alias $mu$ and a register if you want. \begin{verbatim} -#define INNERMUL \ - t = ((fp_word)mu) * ((fp_word)*tmpm++); \ - _c[OFF0] += t; \ - if (_c[OFF0] < (fp_digit)t) ++_c[OFF1]; \ - _c[OFF1] += (t>>DIGIT_BIT); \ - if (_c[OFF1] < (fp_digit)(t>>DIGIT_BIT)) ++_c[OFF2]; +#define INNERMUL \ + do { fp_word t; \ + _c[0] = t = ((fp_word)_c[0] + (fp_word)cy) + \ + (((fp_word)mu) * ((fp_word)*tmpm++)); \ + cy = (t >> DIGIT_BIT); \ + } while (0) \end{verbatim} -This computes the inner product and adds it to the correct set of carry variables. The variable -$\_c$ is a pointer alias to $c[x+y]$ and used to simplify the code. +This computes the inner product and adds it to the destination and carry variable $cy$. +This uses the $mu$ value computed above (can be in a register already) and the +$cy$ which is a chaining carry. Inside the INNERMUL loop the $cy$ value can be kept +inside a register (hint: it always starts as $cy = 0$ in the first iteration). -You can safely alias $\_c$ to a register for INNERMUL by setting it equal to ``c + x'' -\footnote{Where ``c'' is an array on the stack.} by modifying LOOP\_START. +Upon completion of the inner loop the macro LOOP\_END is called which is used to fetch +$cy$ into the variable the C program can see. This is where, if you cached $cy$ in a +register you would copy it to the locally accessible C variable. \begin{verbatim} #define PROPCARRY \ - _c[OFF0+1] += _c[OFF1]; \ - if (_c[OFF0+1] < _c[OFF1]) ++_c[OFF1+1]; \ - _c[OFF1+1] += _c[OFF2]; \ - if (_c[OFF1+1] < _c[OFF2]) ++_c[OFF2+1]; + do { fp_digit t = _c[0] += cy; cy = (t < cy); } while (0) \end{verbatim} This propagates the carry upwards by one digit. diff --git a/tfm.toc b/tfm.toc new file mode 100644 index 0000000..83d12c4 --- /dev/null +++ b/tfm.toc @@ -0,0 +1,33 @@ +\contentsline {chapter}{\numberline {1}Introduction}{1}{chapter.1} +\contentsline {section}{\numberline {1.1}What is TomsFastMath?}{1}{section.1.1} +\contentsline {section}{\numberline {1.2}License}{2}{section.1.2} +\contentsline {section}{\numberline {1.3}Building}{2}{section.1.3} +\contentsline {subsection}{\numberline {1.3.1}Build Limitations}{2}{subsection.1.3.1} +\contentsline {subsection}{\numberline {1.3.2}Optimization Configuration}{2}{subsection.1.3.2} +\contentsline {subsubsection}{x86--32}{3}{section*.3} +\contentsline {subsubsection}{SSE2}{3}{section*.4} +\contentsline {subsubsection}{x86--64}{3}{section*.5} +\contentsline {subsubsection}{ARM}{3}{section*.6} +\contentsline {subsubsection}{PPC32}{3}{section*.7} +\contentsline {subsubsection}{Future Releases}{4}{section*.8} +\contentsline {subsection}{\numberline {1.3.3}Precision Configuration}{4}{subsection.1.3.3} +\contentsline {chapter}{\numberline {2}Getting Started}{5}{chapter.2} +\contentsline {section}{\numberline {2.1}Data Types}{5}{section.2.1} +\contentsline {section}{\numberline {2.2}Initialization}{6}{section.2.2} +\contentsline {subsection}{\numberline {2.2.1}Simple Initialization}{6}{subsection.2.2.1} +\contentsline {subsection}{\numberline {2.2.2}Initialize Small Constants}{6}{subsection.2.2.2} +\contentsline {subsection}{\numberline {2.2.3}Initialize Copy}{6}{subsection.2.2.3} +\contentsline {chapter}{\numberline {3}Arithmetic Operations}{7}{chapter.3} +\contentsline {section}{\numberline {3.1}Odds and Evens}{7}{section.3.1} +\contentsline {section}{\numberline {3.2}Sign Manipulation}{7}{section.3.2} +\contentsline {section}{\numberline {3.3}Comparisons}{8}{section.3.3} +\contentsline {section}{\numberline {3.4}Shifting}{8}{section.3.4} +\contentsline {section}{\numberline {3.5}Basic Algebra}{9}{section.3.5} +\contentsline {section}{\numberline {3.6}Modular Exponentiation}{9}{section.3.6} +\contentsline {section}{\numberline {3.7}Number Theoretic}{9}{section.3.7} +\contentsline {section}{\numberline {3.8}Prime Numbers}{10}{section.3.8} +\contentsline {chapter}{\numberline {4}Porting TomsFastMath}{11}{chapter.4} +\contentsline {section}{\numberline {4.1}Getting Started}{11}{section.4.1} +\contentsline {section}{\numberline {4.2}Multiply with Comba}{11}{section.4.2} +\contentsline {section}{\numberline {4.3}Squaring with Comba}{13}{section.4.3} +\contentsline {section}{\numberline {4.4}Montgomery with Comba}{15}{section.4.4}