kmx git

Commit 0ef44cea9bde015f5c630384dcc6ccee34b618ad

2003-05-29T13:35:26
added libtommath-0.18
diff --git a/bn.pdf b/bn.pdf
index b81b577..fb0aa72 100644
Binary files a/bn.pdf and b/bn.pdf differ
diff --git a/bn.tex b/bn.tex
index 8ba2964..e952494 100644
--- a/bn.tex
+++ b/bn.tex
@@ -1,7 +1,7 @@
 \documentclass[]{article}
 \begin{document}
 
-\title{LibTomMath v0.17 \\ A Free Multiple Precision Integer Library \\ http://math.libtomcrypt.org }
+\title{LibTomMath v0.18 \\ A Free Multiple Precision Integer Library \\ http://math.libtomcrypt.org }
 \author{Tom St Denis \\ tomstdenis@iahu.ca}
 \maketitle
 \newpage
diff --git a/bn_fast_mp_montgomery_reduce.c b/bn_fast_mp_montgomery_reduce.c
index 7591902..149cd9f 100644
--- a/bn_fast_mp_montgomery_reduce.c
+++ b/bn_fast_mp_montgomery_reduce.c
@@ -14,7 +14,7 @@
  */
 #include <tommath.h>
 
-/* computes xR^-1 == x (mod N) via Montgomery Reduction 
+/* computes xR**-1 == x (mod N) via Montgomery Reduction 
  * 
  * This is an optimized implementation of mp_montgomery_reduce 
  * which uses the comba method to quickly calculate the columns of the
@@ -23,76 +23,77 @@
  * Based on Algorithm 14.32 on pp.601 of HAC.
 */
 int
-fast_mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
+fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
 {
   int     ix, res, olduse;
   mp_word W[MP_WARRAY];
 
   /* get old used count */
-  olduse = a->used;
+  olduse = x->used;
 
   /* grow a as required */
-  if (a->alloc < m->used + 1) {
-    if ((res = mp_grow (a, m->used + 1)) != MP_OKAY) {
+  if (x->alloc < n->used + 1) {
+    if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) {
       return res;
     }
   }
 
   {
     register mp_word *_W;
-    register mp_digit *tmpa;
+    register mp_digit *tmpx;
 
     _W = W;
-    tmpa = a->dp;
+    tmpx = x->dp;
 
     /* copy the digits of a into W[0..a->used-1] */
-    for (ix = 0; ix < a->used; ix++) {
-      *_W++ = *tmpa++;
+    for (ix = 0; ix < x->used; ix++) {
+      *_W++ = *tmpx++;
     }
 
     /* zero the high words of W[a->used..m->used*2] */
-    for (; ix < m->used * 2 + 1; ix++) {
+    for (; ix < n->used * 2 + 1; ix++) {
       *_W++ = 0;
     }
   }
 
-  for (ix = 0; ix < m->used; ix++) {
-    /* ui = ai * m' mod b
+  for (ix = 0; ix < n->used; ix++) {
+    /* mu = ai * m' mod b
      *
      * We avoid a double precision multiplication (which isn't required)
-     * by casting the value down to a mp_digit.  Note this requires that W[ix-1] have
-     * the carry cleared (see after the inner loop)
+     * by casting the value down to a mp_digit.  Note this requires 
+     * that W[ix-1] have  the carry cleared (see after the inner loop)
      */
-    register mp_digit ui;
-    ui = (((mp_digit) (W[ix] & MP_MASK)) * mp) & MP_MASK;
+    register mp_digit mu;
+    mu = (((mp_digit) (W[ix] & MP_MASK)) * rho) & MP_MASK;
 
-    /* a = a + ui * m * b^i
+    /* a = a + mu * m * b**i
      *
      * This is computed in place and on the fly.  The multiplication
-     * by b^i is handled by offseting which columns the results
+     * by b**i is handled by offseting which columns the results
      * are added to.
      *
-     * Note the comba method normally doesn't handle carries in the inner loop
-     * In this case we fix the carry from the previous column since the Montgomery
-     * reduction requires digits of the result (so far) [see above] to work.  This is
-     * handled by fixing up one carry after the inner loop.  The carry fixups are done
-     * in order so after these loops the first m->used words of W[] have the carries
-     * fixed
+     * Note the comba method normally doesn't handle carries in the 
+     * inner loop In this case we fix the carry from the previous 
+     * column since the Montgomery reduction requires digits of the 
+     * result (so far) [see above] to work.  This is
+     * handled by fixing up one carry after the inner loop.  The 
+     * carry fixups are done in order so after these loops the 
+     * first m->used words of W[] have the carries fixed
      */
     {
       register int iy;
-      register mp_digit *tmpx;
+      register mp_digit *tmpn;
       register mp_word *_W;
 
       /* alias for the digits of the modulus */
-      tmpx = m->dp;
+      tmpn = n->dp;
 
       /* Alias for the columns set by an offset of ix */
       _W = W + ix;
 
       /* inner loop */
-      for (iy = 0; iy < m->used; iy++) {
-    *_W++ += ((mp_word) ui) * ((mp_word) * tmpx++);
+      for (iy = 0; iy < n->used; iy++) {
+          *_W++ += ((mp_word) mu) * ((mp_word) * tmpn++);
       }
     }
 
@@ -102,44 +103,44 @@ fast_mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
 
 
   {
-    register mp_digit *tmpa;
+    register mp_digit *tmpx;
     register mp_word *_W, *_W1;
 
     /* nox fix rest of carries */
     _W1 = W + ix;
     _W = W + ++ix;
 
-    for (; ix <= m->used * 2 + 1; ix++) {
+    for (; ix <= n->used * 2 + 1; ix++) {
       *_W++ += *_W1++ >> ((mp_word) DIGIT_BIT);
     }
 
-    /* copy out, A = A/b^n
+    /* copy out, A = A/b**n
      *
-     * The result is A/b^n but instead of converting from an array of mp_word
-     * to mp_digit than calling mp_rshd we just copy them in the right
-     * order
+     * The result is A/b**n but instead of converting from an 
+     * array of mp_word to mp_digit than calling mp_rshd 
+     * we just copy them in the right order
      */
-    tmpa = a->dp;
-    _W = W + m->used;
+    tmpx = x->dp;
+    _W = W + n->used;
 
-    for (ix = 0; ix < m->used + 1; ix++) {
-      *tmpa++ = *_W++ & ((mp_word) MP_MASK);
+    for (ix = 0; ix < n->used + 1; ix++) {
+      *tmpx++ = *_W++ & ((mp_word) MP_MASK);
     }
 
     /* zero oldused digits, if the input a was larger than
      * m->used+1 we'll have to clear the digits */
     for (; ix < olduse; ix++) {
-      *tmpa++ = 0;
+      *tmpx++ = 0;
     }
   }
 
   /* set the max used and clamp */
-  a->used = m->used + 1;
-  mp_clamp (a);
+  x->used = n->used + 1;
+  mp_clamp (x);
 
   /* if A >= m then A = A - m */
-  if (mp_cmp_mag (a, m) != MP_LT) {
-    return s_mp_sub (a, m, a);
+  if (mp_cmp_mag (x, n) != MP_LT) {
+    return s_mp_sub (x, n, x);
   }
   return MP_OKAY;
 }
diff --git a/bn_fast_s_mp_sqr.c b/bn_fast_s_mp_sqr.c
index 7ce3839..74179ee 100644
--- a/bn_fast_s_mp_sqr.c
+++ b/bn_fast_s_mp_sqr.c
@@ -16,15 +16,17 @@
 
 /* fast squaring
  *
- * This is the comba method where the columns of the product are computed first
- * then the carries are computed.  This has the effect of making a very simple
- * inner loop that is executed the most
+ * This is the comba method where the columns of the product 
+ * are computed first then the carries are computed.  This 
+ * has the effect of making a very simple inner loop that 
+ * is executed the most
  *
  * W2 represents the outer products and W the inner.
  *
- * A further optimizations is made because the inner products are of the form
- * "A * B * 2".  The *2 part does not need to be computed until the end which is
- * good because 64-bit shifts are slow!
+ * A further optimizations is made because the inner 
+ * products are of the form "A * B * 2".  The *2 part does 
+ * not need to be computed until the end which is good 
+ * because 64-bit shifts are slow!
  *
  * Based on Algorithm 14.16 on pp.597 of HAC.
  *
@@ -48,26 +50,15 @@ fast_s_mp_sqr (mp_int * a, mp_int * b)
    * Note that there are two buffers.  Since squaring requires
    * a outter and inner product and the inner product requires
    * computing a product and doubling it (a relatively expensive
-   * op to perform n^2 times if you don't have to) the inner and
+   * op to perform n**2 times if you don't have to) the inner and
    * outer products are computed in different buffers.  This way
    * the inner product can be doubled using n doublings instead of
-   * n^2
+   * n**2
    */
   memset (W, 0, newused * sizeof (mp_word));
   memset (W2, 0, newused * sizeof (mp_word));
 
-/* note optimization
- * values in W2 are only written in even locations which means
- * we can collapse the array to 256 words [and fixup the memset above]
- * provided we also fix up the summations below.  Ideally
- * the fixup loop should be unrolled twice to handle the even/odd
- * cases, and then a final step to handle odd cases [e.g. newused == odd]
- *
- * This will not only save ~8*256 = 2KB of stack but lower the number of
- * operations required to finally fix up the columns
- */
-
-  /* This computes the inner product.  To simplify the inner N^2 loop
+  /* This computes the inner product.  To simplify the inner N**2 loop
    * the multiplication by two is done afterwards in the N loop.
    */
   for (ix = 0; ix < pa; ix++) {
@@ -101,18 +92,19 @@ fast_s_mp_sqr (mp_int * a, mp_int * b)
   }
 
   /* setup dest */
-  olduse = b->used;
+  olduse  = b->used;
   b->used = newused;
 
-  /* double first value, since the inner products are half of what they should be */
-  W[0] += W[0] + W2[0];
-
   /* now compute digits */
   {
     register mp_digit *tmpb;
 
-    tmpb = b->dp;
+    /* double first value, since the inner products are 
+     * half of what they should be 
+     */
+    W[0] += W[0] + W2[0];
 
+    tmpb = b->dp;
     for (ix = 1; ix < newused; ix++) {
       /* double/add next digit */
       W[ix] += W[ix] + W2[ix];
@@ -120,9 +112,13 @@ fast_s_mp_sqr (mp_int * a, mp_int * b)
       W[ix] = W[ix] + (W[ix - 1] >> ((mp_word) DIGIT_BIT));
       *tmpb++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
     }
+    /* set the last value.  Note even if the carry is zero 
+     * this is required since the next step will not zero 
+     * it if b originally had a value at b->dp[2*a.used]
+     */
     *tmpb++ = (mp_digit) (W[(newused) - 1] & ((mp_word) MP_MASK));
 
-    /* clear high */
+    /* clear high digits */
     for (; ix < olduse; ix++) {
       *tmpb++ = 0;
     }
diff --git a/bn_mp_2expt.c b/bn_mp_2expt.c
index 415aa1e..96cf84e 100644
--- a/bn_mp_2expt.c
+++ b/bn_mp_2expt.c
@@ -14,7 +14,7 @@
  */
 #include <tommath.h>
 
-/* computes a = 2^b 
+/* computes a = 2**b 
  *
  * Simple algorithm which zeroes the int, grows it then just sets one bit
  * as required.
diff --git a/bn_mp_copy.c b/bn_mp_copy.c
index ebdca5a..4e3eef8 100644
--- a/bn_mp_copy.c
+++ b/bn_mp_copy.c
@@ -21,7 +21,7 @@ mp_copy (mp_int * a, mp_int * b)
   int     res, n;
 
   /* if dst == src do nothing */
-  if (a == b || a->dp == b->dp) {
+  if (a == b) {
     return MP_OKAY;
   }
 
diff --git a/bn_mp_count_bits.c b/bn_mp_count_bits.c
index 3833ce6..e48bda1 100644
--- a/bn_mp_count_bits.c
+++ b/bn_mp_count_bits.c
@@ -21,11 +21,15 @@ mp_count_bits (mp_int * a)
   int     r;
   mp_digit q;
 
+  /* shortcut */
   if (a->used == 0) {
     return 0;
   }
 
+  /* get number of digits and add that */
   r = (a->used - 1) * DIGIT_BIT;
+  
+  /* take the last digit and count the bits in it */
   q = a->dp[a->used - 1];
   while (q > ((mp_digit) 0)) {
     ++r;
diff --git a/bn_mp_div_2d.c b/bn_mp_div_2d.c
index f050c29..18bf904 100644
--- a/bn_mp_div_2d.c
+++ b/bn_mp_div_2d.c
@@ -14,7 +14,7 @@
  */
 #include <tommath.h>
 
-/* shift right by a certain bit count (store quotient in c, remainder in d) */
+/* shift right by a certain bit count (store quotient in c, optional remainder in d) */
 int
 mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
 {
@@ -81,7 +81,6 @@ mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
     }
   }
   mp_clamp (c);
-  res = MP_OKAY;
   if (d != NULL) {
     mp_exch (&t, d);
   }
diff --git a/bn_mp_div_3.c b/bn_mp_div_3.c
new file mode 100644
index 0000000..40937f4
--- /dev/null
+++ b/bn_mp_div_3.c
@@ -0,0 +1,64 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* divide by three (based on routine from MPI and the GMP manual) */
+int
+mp_div_3 (mp_int * a, mp_int *c, mp_digit * d)
+{
+  mp_int   q;
+  mp_word  w, t;
+  mp_digit b;
+  int      res, ix;
+  
+  /* b = 2**DIGIT_BIT / 3 */
+  b = (((mp_word)1) << ((mp_word)DIGIT_BIT)) / ((mp_word)3);
+
+  if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
+     return res;
+  }
+  
+  q.used = a->used;
+  q.sign = a->sign;
+  w = 0;
+  for (ix = a->used - 1; ix >= 0; ix--) {
+     w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
+     
+     if (w >= 3) {
+        t = (w * ((mp_word)b)) >> ((mp_word)DIGIT_BIT);
+        w -= (t << ((mp_word)1)) + t;
+        while (w >= 3) {
+           t += 1;
+           w -= 3;
+        }
+      } else {
+        t = 0;
+      }
+      q.dp[ix] = t;
+  }
+  
+  if (d != NULL) {
+     *d = w;
+  }
+  
+  if (c != NULL) {
+     mp_clamp(&q);
+     mp_exch(&q, c);
+  }
+  mp_clear(&q);
+  
+  return res;
+}
+
diff --git a/bn_mp_div_d.c b/bn_mp_div_d.c
index 4b33a42..459ca95 100644
--- a/bn_mp_div_d.c
+++ b/bn_mp_div_d.c
@@ -14,31 +14,51 @@
  */
 #include <tommath.h>
 
-/* single digit division */
+/* single digit division (based on routine from MPI) */
 int
 mp_div_d (mp_int * a, mp_digit b, mp_int * c, mp_digit * d)
 {
-  mp_int  t, t2;
-  int     res;
-
-  if ((res = mp_init (&t)) != MP_OKAY) {
-    return res;
+  mp_int  q;
+  mp_word w, t;
+  int     res, ix;
+  
+  if (b == 0) {
+     return MP_VAL;
   }
-
-  if ((res = mp_init (&t2)) != MP_OKAY) {
-    mp_clear (&t);
-    return res;
+  
+  if (b == 3) {
+     return mp_div_3(a, c, d);
   }
-
-  mp_set (&t, b);
-  res = mp_div (a, &t, c, &t2);
-
-  /* set remainder if not null */
+  
+  if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
+     return res;
+  }
+  
+  q.used = a->used;
+  q.sign = a->sign;
+  w = 0;
+  for (ix = a->used - 1; ix >= 0; ix--) {
+     w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
+     
+     if (w >= b) {
+        t = w / b;
+        w = w % b;
+      } else {
+        t = 0;
+      }
+      q.dp[ix] = t;
+  }
+  
   if (d != NULL) {
-    *d = t2.dp[0];
+     *d = w;
   }
-
-  mp_clear (&t);
-  mp_clear (&t2);
+  
+  if (c != NULL) {
+     mp_clamp(&q);
+     mp_exch(&q, c);
+  }
+  mp_clear(&q);
+  
   return res;
 }
+
diff --git a/bn_mp_dr_reduce.c b/bn_mp_dr_reduce.c
index c8488e0..0fece61 100644
--- a/bn_mp_dr_reduce.c
+++ b/bn_mp_dr_reduce.c
@@ -14,7 +14,7 @@
  */
 #include <tommath.h>
 
-/* reduce "a" in place modulo "b" using the Diminished Radix algorithm.
+/* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
  *
  * Based on algorithm from the paper
  *
@@ -23,107 +23,64 @@
  *          POSTECH Information Research Laboratories
  *
  * The modulus must be of a special format [see manual]
+ *
+ * Has been modified to use algorithm 7.10 from the LTM book instead
  */
 int
-mp_dr_reduce (mp_int * a, mp_int * b, mp_digit mp)
+mp_dr_reduce (mp_int * x, mp_int * n, mp_digit k)
 {
-  int     err, i, j, k;
-  mp_word r;
-  mp_digit mu, *tmpj, *tmpi;
-
-  /* k = digits in modulus */
-  k = b->used;
-
-  /* ensure that "a" has at least 2k digits */
-  if (a->alloc < k + k) {
-    if ((err = mp_grow (a, k + k)) != MP_OKAY) {
+  int      err, i, m;
+  mp_word  r;
+  mp_digit mu, *tmpx1, *tmpx2;
+  
+  /* m = digits in modulus */
+  m = n->used;
+  
+  /* ensure that "x" has at least 2m digits */
+  if (x->alloc < m + m) {
+    if ((err = mp_grow (x, m + m)) != MP_OKAY) {
       return err;
     }
   }
 
-  /* alias for a->dp[i] */
-  tmpi = a->dp + k + k - 1;
-
-  /* for (i = 2k - 1; i >= k; i = i - 1)
-   *
-   * This is the main loop of the reduction.  Note that at the end
-   * the words above position k are not zeroed as expected.  The end
-   * result is that the digits from 0 to k-1 are the residue.  So
-   * we have to clear those afterwards.
-   */
-  for (i = k + k - 1; i >= k; i = i - 1) {
-    /* x[i - 1 : i - k] += x[i]*mp */
-
-    /* x[i] * mp */
-    r = ((mp_word) *tmpi--) * ((mp_word) mp);
-
-    /* now add r to x[i-1:i-k]
-     *
-     * First add it to the first digit x[i-k] then form the carry
-     * then enter the main loop
-     */
-    j = i - k;
-
-    /* alias for a->dp[j] */
-    tmpj = a->dp + j;
-
-    /* add digit */
-    *tmpj += (mp_digit)(r & MP_MASK);
-
-    /* this is the carry */
-    mu = (r >> ((mp_word) DIGIT_BIT)) + (*tmpj >> DIGIT_BIT);
-
-    /* clear carry from a->dp[j]  */
-    *tmpj++ &= MP_MASK;
-
-    /* now add rest of the digits
-     *
-     * Note this is basically a simple single digit addition to
-     * a larger multiple digit number.  This is optimized somewhat
-     * because the propagation of carries is not likely to move
-     * more than a few digits.
-     *
-     */
-    for (++j; mu != 0 && j <= (i - 1); ++j) {
-      *tmpj   += mu;
-      mu       = *tmpj >> DIGIT_BIT;
-      *tmpj++ &= MP_MASK;
-    }
-
-    /* if final carry */
-    if (mu != 0) {
-      /* add mp to this to correct */
-      j = i - k;
-      tmpj = a->dp + j;
-
-      *tmpj += mp;
-      mu = *tmpj >> DIGIT_BIT;
-      *tmpj++ &= MP_MASK;
-
-      /* now handle carries */
-      for (++j; mu != 0 && j <= (i - 1); j++) {
-          *tmpj   += mu;
-          mu       = *tmpj >> DIGIT_BIT;
-          *tmpj++ &= MP_MASK;
-      }
-    }
+/* top of loop, this is where the code resumes if 
+ * another reduction pass is required.
+ */
+top:
+  /* aliases for digits */
+  /* alias for lower half of x */
+  tmpx1 = x->dp;
+  
+  /* alias for upper half of x, or x/B**m */
+  tmpx2 = x->dp + m;
+  
+  /* set carry to zero */
+  mu = 0;
+  
+  /* compute (x mod B**m) + mp * [x/B**m] inline and inplace */
+  for (i = 0; i < m; i++) {
+      r         = ((mp_word)*tmpx2++) * ((mp_word)k) + *tmpx1 + mu;
+      *tmpx1++  = r & MP_MASK;
+      mu        = r >> ((mp_word)DIGIT_BIT);
   }
-
-  /* zero words above k */
-  tmpi = a->dp + k;
-  for (i = k; i < a->used; i++) {
-      *tmpi++ = 0;
+  
+  /* set final carry */
+  *tmpx1++ = mu;
+  
+  /* zero words above m */
+  for (i = m + 1; i < x->used; i++) {
+      *tmpx1++ = 0;
   }
 
   /* clamp, sub and return */
-  mp_clamp (a);
+  mp_clamp (x);
 
-  /* if a >= b [b == modulus] then subtract the modulus to fix up */
-  if (mp_cmp_mag (a, b) != MP_LT) {
-    return s_mp_sub (a, b, a);
+  /* if x >= n then subtract and reduce again 
+   * Each successive "recursion" makes the input smaller and smaller.
+   */
+  if (mp_cmp_mag (x, n) != MP_LT) {
+    s_mp_sub(x, n, x);
+    goto top;
   }
   return MP_OKAY;
 }
-
-
-
diff --git a/bn_mp_dr_setup.c b/bn_mp_dr_setup.c
index 62dba02..c1dbbbb 100644
--- a/bn_mp_dr_setup.c
+++ b/bn_mp_dr_setup.c
@@ -20,6 +20,7 @@ void mp_dr_setup(mp_int *a, mp_digit *d)
    /* the casts are required if DIGIT_BIT is one less than
     * the number of bits in a mp_digit [e.g. DIGIT_BIT==31]
     */
-   *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) - ((mp_word)a->dp[0]));
+   *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) - 
+        ((mp_word)a->dp[0]));
 }
 
diff --git a/bn_mp_expt_d.c b/bn_mp_expt_d.c
index 1f76830..cf5c8ed 100644
--- a/bn_mp_expt_d.c
+++ b/bn_mp_expt_d.c
@@ -14,7 +14,7 @@
  */
 #include <tommath.h>
 
-/* calculate c = a^b  using a square-multiply algorithm */
+/* calculate c = a**b  using a square-multiply algorithm */
 int
 mp_expt_d (mp_int * a, mp_digit b, mp_int * c)
 {
diff --git a/bn_mp_exptmod.c b/bn_mp_exptmod.c
index 573f760..2131522 100644
--- a/bn_mp_exptmod.c
+++ b/bn_mp_exptmod.c
@@ -14,7 +14,6 @@
  */
 #include <tommath.h>
 
-static int f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y);
 
 /* this is a shell function that calls either the normal or Montgomery
  * exptmod functions.  Originally the call to the montgomery code was
@@ -55,212 +54,22 @@ mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
         return err;
      }
 
-     /* and now compute (1/G)^|X| instead of G^X [X < 0] */
+     /* and now compute (1/G)**|X| instead of G**X [X < 0] */
      err = mp_exptmod(&tmpG, &tmpX, P, Y);
      mp_clear_multi(&tmpG, &tmpX, NULL);
      return err;
   }
 
-
   dr = mp_dr_is_modulus(P);
+  if (dr == 0) {
+     dr = mp_reduce_is_2k(P) << 1;
+  }
+  
   /* if the modulus is odd use the fast method */
-  if ((mp_isodd (P) == 1 || dr == 1) && P->used > 4) {
+  if ((mp_isodd (P) == 1 || dr !=  0) && P->used > 4) {
     return mp_exptmod_fast (G, X, P, Y, dr);
   } else {
-    return f_mp_exptmod (G, X, P, Y);
+    return s_mp_exptmod (G, X, P, Y);
   }
 }
 
-static int
-f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
-{
-  mp_int  M[256], res, mu;
-  mp_digit buf;
-  int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
-
-  /* find window size */
-  x = mp_count_bits (X);
-  if (x <= 7) {
-    winsize = 2;
-  } else if (x <= 36) {
-    winsize = 3;
-  } else if (x <= 140) {
-    winsize = 4;
-  } else if (x <= 450) {
-    winsize = 5;
-  } else if (x <= 1303) {
-    winsize = 6;
-  } else if (x <= 3529) {
-    winsize = 7;
-  } else {
-    winsize = 8;
-  }
-
-#ifdef MP_LOW_MEM
-    if (winsize > 5) {
-       winsize = 5;
-    }
-#endif
-
-  /* init G array */
-  for (x = 0; x < (1 << winsize); x++) {
-    if ((err = mp_init_size (&M[x], 1)) != MP_OKAY) {
-      for (y = 0; y < x; y++) {
-        mp_clear (&M[y]);
-      }
-      return err;
-    }
-  }
-
-  /* create mu, used for Barrett reduction */
-  if ((err = mp_init (&mu)) != MP_OKAY) {
-    goto __M;
-  }
-  if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) {
-    goto __MU;
-  }
-
-  /* create M table
-   *
-   * The M table contains powers of the input base, e.g. M[x] = G^x mod P
-   *
-   * The first half of the table is not computed though accept for M[0] and M[1]
-   */
-  if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) {
-    goto __MU;
-  }
-
-  /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */
-  if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
-    goto __MU;
-  }
-
-  for (x = 0; x < (winsize - 1); x++) {
-    if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
-      goto __MU;
-    }
-    if ((err = mp_reduce (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) {
-      goto __MU;
-    }
-  }
-
-  /* create upper table */
-  for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
-    if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
-      goto __MU;
-    }
-    if ((err = mp_reduce (&M[x], P, &mu)) != MP_OKAY) {
-      goto __MU;
-    }
-  }
-
-  /* setup result */
-  if ((err = mp_init (&res)) != MP_OKAY) {
-    goto __MU;
-  }
-  mp_set (&res, 1);
-
-  /* set initial mode and bit cnt */
-  mode   = 0;
-  bitcnt = 1;
-  buf    = 0;
-  digidx = X->used - 1;
-  bitcpy = bitbuf = 0;
-
-  for (;;) {
-    /* grab next digit as required */
-    if (--bitcnt == 0) {
-      if (digidx == -1) {
-        break;
-      }
-      buf = X->dp[digidx--];
-      bitcnt = (int) DIGIT_BIT;
-    }
-
-    /* grab the next msb from the exponent */
-    y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
-    buf <<= (mp_digit)1;
-
-    /* if the bit is zero and mode == 0 then we ignore it
-     * These represent the leading zero bits before the first 1 bit
-     * in the exponent.  Technically this opt is not required but it
-     * does lower the # of trivial squaring/reductions used
-     */
-    if (mode == 0 && y == 0)
-      continue;
-
-    /* if the bit is zero and mode == 1 then we square */
-    if (mode == 1 && y == 0) {
-      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
-        goto __RES;
-      }
-      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
-        goto __RES;
-      }
-      continue;
-    }
-
-    /* else we add it to the window */
-    bitbuf |= (y << (winsize - ++bitcpy));
-    mode = 2;
-
-    if (bitcpy == winsize) {
-      /* ok window is filled so square as required and multiply  */
-      /* square first */
-      for (x = 0; x < winsize; x++) {
-        if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
-          goto __RES;
-        }
-        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
-          goto __RES;
-        }
-      }
-
-      /* then multiply */
-      if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) {
-        goto __MU;
-      }
-      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
-        goto __MU;
-      }
-
-      /* empty window and reset */
-      bitcpy = bitbuf = 0;
-      mode = 1;
-    }
-  }
-
-  /* if bits remain then square/multiply */
-  if (mode == 2 && bitcpy > 0) {
-    /* square then multiply if the bit is set */
-    for (x = 0; x < bitcpy; x++) {
-      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
-        goto __RES;
-      }
-      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
-        goto __RES;
-      }
-
-      bitbuf <<= 1;
-      if ((bitbuf & (1 << winsize)) != 0) {
-        /* then multiply */
-        if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) {
-          goto __RES;
-        }
-        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
-          goto __RES;
-        }
-      }
-    }
-  }
-
-  mp_exch (&res, Y);
-  err = MP_OKAY;
-__RES:mp_clear (&res);
-__MU:mp_clear (&mu);
-__M:
-  for (x = 0; x < (1 << winsize); x++) {
-    mp_clear (&M[x]);
-  }
-  return err;
-}
diff --git a/bn_mp_exptmod_fast.c b/bn_mp_exptmod_fast.c
index 7edf736..54de53d 100644
--- a/bn_mp_exptmod_fast.c
+++ b/bn_mp_exptmod_fast.c
@@ -27,6 +27,11 @@ mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
   mp_int  M[256], res;
   mp_digit buf, mp;
   int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
+  
+  /* use a pointer to the reduction algorithm.  This allows us to use
+   * one of many reduction algorithms without modding the guts of
+   * the code with if statements everywhere.  
+   */
   int     (*redux)(mp_int*,mp_int*,mp_digit);
 
   /* find window size */
@@ -64,6 +69,7 @@ mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
     }
   }
 
+  /* determine and setup reduction code */
   if (redmode == 0) {
      /* now setup montgomery  */
      if ((err = mp_montgomery_setup (P, &mp)) != MP_OKAY) {
@@ -71,17 +77,23 @@ mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
      }
      
      /* automatically pick the comba one if available (saves quite a few calls/ifs) */
-     if ( ((P->used * 2 + 1) < MP_WARRAY) &&
+     if (((P->used * 2 + 1) < MP_WARRAY) &&
           P->used < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
         redux = fast_mp_montgomery_reduce;
      } else {
         /* use slower baselien method */
         redux = mp_montgomery_reduce;
      }
-  } else {
+  } else if (redmode == 1) {
      /* setup DR reduction */
      mp_dr_setup(P, &mp);
      redux = mp_dr_reduce;
+  } else {
+     /* setup 2k reduction */
+     if ((err = mp_reduce_2k_setup(P, &mp)) != MP_OKAY) {
+        goto __M;
+     }
+     redux = mp_reduce_2k;
   }
 
   /* setup result */
@@ -142,7 +154,8 @@ mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
   bitcnt = 1;
   buf    = 0;
   digidx = X->used - 1;
-  bitcpy = bitbuf = 0;
+  bitcpy = 0;
+  bitbuf = 0;
 
   for (;;) {
     /* grab next digit as required */
@@ -203,7 +216,8 @@ mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
       }
 
       /* empty window and reset */
-      bitcpy = bitbuf = 0;
+      bitcpy = 0;
+      bitbuf = 0;
       mode = 1;
     }
   }
@@ -233,7 +247,7 @@ mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
   }
 
   if (redmode == 0) {
-     /* fixup result */
+     /* fixup result if Montgomery reduction is used */
      if ((err = mp_montgomery_reduce (&res, P, mp)) != MP_OKAY) {
        goto __RES;
      }
diff --git a/bn_mp_init.c b/bn_mp_init.c
index 3af7499..2cfa002 100644
--- a/bn_mp_init.c
+++ b/bn_mp_init.c
@@ -24,7 +24,7 @@ mp_init (mp_int * a)
     return MP_MEM;
   }
 
-  /* set the used to zero, allocated digit to the default precision
+  /* set the used to zero, allocated digits to the default precision
    * and sign to positive */
   a->used  = 0;
   a->alloc = MP_PREC;
diff --git a/bn_mp_karatsuba_mul.c b/bn_mp_karatsuba_mul.c
index f720a11..e52a49d 100644
--- a/bn_mp_karatsuba_mul.c
+++ b/bn_mp_karatsuba_mul.c
@@ -14,24 +14,34 @@
  */
 #include <tommath.h>
 
-/* c = |a| * |b| using Karatsuba Multiplication using three half size multiplications
+/* c = |a| * |b| using Karatsuba Multiplication using 
+ * three half size multiplications
  *
- * Let B represent the radix [e.g. 2**DIGIT_BIT] and let n represent half of the number of digits in the min(a,b)
+ * Let B represent the radix [e.g. 2**DIGIT_BIT] and 
+ * let n represent half of the number of digits in 
+ * the min(a,b)
  *
- * a = a1 * B^n + a0
- * b = b1 * B^n + b0
+ * a = a1 * B**n + a0
+ * b = b1 * B**n + b0
  *
- * Then, a * b => a1b1 * B^2n + ((a1 - b1)(a0 - b0) + a0b0 + a1b1) * B + a0b0
+ * Then, a * b => 
+   a1b1 * B**2n + ((a1 - a0)(b1 - b0) + a0b0 + a1b1) * B + a0b0
  *
- * Note that a1b1 and a0b0 are used twice and only need to be computed once.  So in total
- * three half size (half # of digit) multiplications are performed, a0b0, a1b1 and (a1-b1)(a0-b0)
+ * Note that a1b1 and a0b0 are used twice and only need to be 
+ * computed once.  So in total three half size (half # of 
+ * digit) multiplications are performed, a0b0, a1b1 and 
+ * (a1-b1)(a0-b0)
  *
- * Note that a multiplication of half the digits requires 1/4th the number of single precision 
- * multiplications so in total after one call 25% of the single precision multiplications are saved.
- * Note also that the call to mp_mul can end up back in this function if the a0, a1, b0, or b1 are above
- * the threshold.  This is known as divide-and-conquer and leads to the famous O(N^lg(3)) or O(N^1.584) work which
- * is asymptopically lower than the standard O(N^2) that the baseline/comba methods use.  Generally though the 
- * overhead of this method doesn't pay off until a certain size (N ~ 80) is reached.
+ * Note that a multiplication of half the digits requires
+ * 1/4th the number of single precision multiplications so in 
+ * total after one call 25% of the single precision multiplications 
+ * are saved.  Note also that the call to mp_mul can end up back 
+ * in this function if the a0, a1, b0, or b1 are above the threshold.  
+ * This is known as divide-and-conquer and leads to the famous 
+ * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than 
+ * the standard O(N**2) that the baseline/comba methods use.  
+ * Generally though the overhead of this method doesn't pay off 
+ * until a certain size (N ~ 80) is reached.
  */
 int
 mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
@@ -101,14 +111,15 @@ mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
     }
   }
 
-  /* only need to clamp the lower words since by definition the upper words x1/y1 must
-   * have a known number of digits
+  /* only need to clamp the lower words since by definition the 
+   * upper words x1/y1 must have a known number of digits
    */
   mp_clamp (&x0);
   mp_clamp (&y0);
 
   /* now calc the products x0y0 and x1y1 */
-  if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY)  /* after this x0 is no longer required, free temp [x0==t2]! */
+  /* after this x0 is no longer required, free temp [x0==t2]! */
+  if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY)  
     goto X1Y1;          /* x0y0 = x0*y0 */
   if (mp_mul (&x1, &y1, &x1y1) != MP_OKAY)
     goto X1Y1;          /* x1y1 = x1*y1 */
diff --git a/bn_mp_karatsuba_sqr.c b/bn_mp_karatsuba_sqr.c
index c3da38a..c9e3e67 100644
--- a/bn_mp_karatsuba_sqr.c
+++ b/bn_mp_karatsuba_sqr.c
@@ -14,10 +14,12 @@
  */
 #include <tommath.h>
 
-/* Karatsuba squaring, computes b = a*a using three half size squarings
+/* Karatsuba squaring, computes b = a*a using three 
+ * half size squarings
  *
- * See comments of mp_karatsuba_mul for details.  It is essentially the same algorithm
- * but merely tuned to perform recursive squarings.
+ * See comments of mp_karatsuba_mul for details.  It 
+ * is essentially the same algorithm but merely 
+ * tuned to perform recursive squarings.
  */
 int
 mp_karatsuba_sqr (mp_int * a, mp_int * b)
@@ -74,32 +76,32 @@ mp_karatsuba_sqr (mp_int * a, mp_int * b)
 
   /* now calc the products x0*x0 and x1*x1 */
   if (mp_sqr (&x0, &x0x0) != MP_OKAY)
-    goto X1X1;                  /* x0x0 = x0*x0 */
+    goto X1X1;           /* x0x0 = x0*x0 */
   if (mp_sqr (&x1, &x1x1) != MP_OKAY)
-    goto X1X1;                  /* x1x1 = x1*x1 */
+    goto X1X1;           /* x1x1 = x1*x1 */
 
-  /* now calc (x1-x0)^2 */
+  /* now calc (x1-x0)**2 */
   if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = x1 - x0 */
+    goto X1X1;           /* t1 = x1 - x0 */
   if (mp_sqr (&t1, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = (x1 - x0) * (x1 - x0) */
+    goto X1X1;           /* t1 = (x1 - x0) * (x1 - x0) */
 
   /* add x0y0 */
   if (s_mp_add (&x0x0, &x1x1, &t2) != MP_OKAY)
-    goto X1X1;                  /* t2 = x0y0 + x1y1 */
+    goto X1X1;           /* t2 = x0x0 + x1x1 */
   if (mp_sub (&t2, &t1, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = x0y0 + x1y1 - (x1-x0)*(y1-y0) */
+    goto X1X1;           /* t1 = x0x0 + x1x1 - (x1-x0)*(x1-x0) */
 
   /* shift by B */
   if (mp_lshd (&t1, B) != MP_OKAY)
-    goto X1X1;                  /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */
+    goto X1X1;           /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */
   if (mp_lshd (&x1x1, B * 2) != MP_OKAY)
-    goto X1X1;                  /* x1y1 = x1y1 << 2*B */
+    goto X1X1;           /* x1x1 = x1x1 << 2*B */
 
   if (mp_add (&x0x0, &t1, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = x0y0 + t1 */
+    goto X1X1;           /* t1 = x0x0 + t1 */
   if (mp_add (&t1, &x1x1, b) != MP_OKAY)
-    goto X1X1;                  /* t1 = x0y0 + t1 + x1y1 */
+    goto X1X1;           /* t1 = x0x0 + t1 + x1x1 */
 
   err = MP_OKAY;
 
diff --git a/bn_mp_lshd.c b/bn_mp_lshd.c
index 87a376b..1ac185c 100644
--- a/bn_mp_lshd.c
+++ b/bn_mp_lshd.c
@@ -33,29 +33,29 @@ mp_lshd (mp_int * a, int b)
   }
 
   {
-    register mp_digit *tmpa, *tmpaa;
+    register mp_digit *top, *bottom;
 
-    /* increment the used by the shift amount than copy upwards */
+    /* increment the used by the shift amount then copy upwards */
     a->used += b;
 
     /* top */
-    tmpa = a->dp + a->used - 1;
+    top = a->dp + a->used - 1;
 
     /* base */
-    tmpaa = a->dp + a->used - 1 - b;
+    bottom = a->dp + a->used - 1 - b;
 
     /* much like mp_rshd this is implemented using a sliding window
      * except the window goes the otherway around.  Copying from
      * the bottom to the top.  see bn_mp_rshd.c for more info.
      */
     for (x = a->used - 1; x >= b; x--) {
-      *tmpa-- = *tmpaa--;
+      *top-- = *bottom--;
     }
 
     /* zero the lower digits */
-    tmpa = a->dp;
+    top = a->dp;
     for (x = 0; x < b; x++) {
-      *tmpa++ = 0;
+      *top++ = 0;
     }
   }
   return MP_OKAY;
diff --git a/bn_mp_mod_d.c b/bn_mp_mod_d.c
index 42f3807..7ebb61e 100644
--- a/bn_mp_mod_d.c
+++ b/bn_mp_mod_d.c
@@ -17,31 +17,5 @@
 int
 mp_mod_d (mp_int * a, mp_digit b, mp_digit * c)
 {
-  mp_int  t, t2;
-  int     res;
-
-
-  if ((res = mp_init (&t)) != MP_OKAY) {
-    return res;
-  }
-
-  if ((res = mp_init (&t2)) != MP_OKAY) {
-    mp_clear (&t);
-    return res;
-  }
-
-  mp_set (&t, b);
-  mp_div (a, &t, NULL, &t2);
-
-  if (t2.sign == MP_NEG) {
-    if ((res = mp_add_d (&t2, b, &t2)) != MP_OKAY) {
-      mp_clear (&t);
-      mp_clear (&t2);
-      return res;
-    }
-  }
-  *c = t2.dp[0];
-  mp_clear (&t);
-  mp_clear (&t2);
-  return MP_OKAY;
+  return mp_div_d(a, b, NULL, c);
 }
diff --git a/bn_mp_montgomery_reduce.c b/bn_mp_montgomery_reduce.c
index 69a5364..7c1c804 100644
--- a/bn_mp_montgomery_reduce.c
+++ b/bn_mp_montgomery_reduce.c
@@ -14,12 +14,12 @@
  */
 #include <tommath.h>
 
-/* computes xR^-1 == x (mod N) via Montgomery Reduction */
+/* computes xR**-1 == x (mod N) via Montgomery Reduction */
 int
-mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
+mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
 {
   int     ix, res, digs;
-  mp_digit ui;
+  mp_digit mu;
 
   /* can the fast reduction [comba] method be used?
    *
@@ -27,55 +27,60 @@ mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
    * than the available columns [255 per default] since carries
    * are fixed up in the inner loop.
    */
-  digs = m->used * 2 + 1;
-  if ((digs < MP_WARRAY)
-      && m->used < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
-    return fast_mp_montgomery_reduce (a, m, mp);
+  digs = n->used * 2 + 1;
+  if ((digs < MP_WARRAY) && 
+      n->used < 
+      (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
+    return fast_mp_montgomery_reduce (x, n, rho);
   }
 
   /* grow the input as required */
-  if (a->alloc < m->used * 2 + 1) {
-    if ((res = mp_grow (a, m->used * 2 + 1)) != MP_OKAY) {
+  if (x->alloc < digs) {
+    if ((res = mp_grow (x, digs)) != MP_OKAY) {
       return res;
     }
   }
-  a->used = m->used * 2 + 1;
+  x->used = digs;
 
-  for (ix = 0; ix < m->used; ix++) {
-    /* ui = ai * m' mod b */
-    ui = (a->dp[ix] * mp) & MP_MASK;
+  for (ix = 0; ix < n->used; ix++) {
+    /* mu = ai * m' mod b */
+    mu = (x->dp[ix] * rho) & MP_MASK;
 
-    /* a = a + ui * m * b^i */
+    /* a = a + mu * m * b**i */
     {
       register int iy;
-      register mp_digit *tmpx, *tmpy, mu;
+      register mp_digit *tmpn, *tmpx, u;
       register mp_word r;
 
       /* aliases */
-      tmpx = m->dp;
-      tmpy = a->dp + ix;
+      tmpn = n->dp;
+      tmpx = x->dp + ix;
 
-      mu = 0;
-      for (iy = 0; iy < m->used; iy++) {
-        r = ((mp_word) ui) * ((mp_word) * tmpx++) + ((mp_word) mu) + ((mp_word) * tmpy);
-        mu = (r >> ((mp_word) DIGIT_BIT));
-        *tmpy++ = (r & ((mp_word) MP_MASK));
+      /* set the carry to zero */
+      u = 0;
+      
+      /* Multiply and add in place */
+      for (iy = 0; iy < n->used; iy++) {
+        r = ((mp_word) mu) * ((mp_word) * tmpn++) + 
+            ((mp_word) u) + ((mp_word) * tmpx);
+        u = (r >> ((mp_word) DIGIT_BIT));
+        *tmpx++ = (r & ((mp_word) MP_MASK));
       }
       /* propagate carries */
-      while (mu) {
-        *tmpy += mu;
-        mu = (*tmpy >> DIGIT_BIT) & 1;
-        *tmpy++ &= MP_MASK;
+      while (u) {
+        *tmpx += u;
+        u = *tmpx >> DIGIT_BIT;
+        *tmpx++ &= MP_MASK;
       }
     }
   }
 
-  /* A = A/b^n */
-  mp_rshd (a, m->used);
+  /* x = x/b**n.used */
+  mp_rshd (x, n->used);
 
   /* if A >= m then A = A - m */
-  if (mp_cmp_mag (a, m) != MP_LT) {
-    return s_mp_sub (a, m, a);
+  if (mp_cmp_mag (x, n) != MP_LT) {
+    return s_mp_sub (x, n, x);
   }
 
   return MP_OKAY;
diff --git a/bn_mp_montgomery_setup.c b/bn_mp_montgomery_setup.c
index e59fab6..29aead7 100644
--- a/bn_mp_montgomery_setup.c
+++ b/bn_mp_montgomery_setup.c
@@ -16,38 +16,38 @@
 
 /* setups the montgomery reduction stuff */
 int
-mp_montgomery_setup (mp_int * a, mp_digit * mp)
+mp_montgomery_setup (mp_int * n, mp_digit * rho)
 {
   mp_digit x, b;
 
-/* fast inversion mod 2^k
+/* fast inversion mod 2**k
  *
  * Based on the fact that
  *
- * XA = 1 (mod 2^n)  =>  (X(2-XA)) A = 1 (mod 2^2n)
- *                   =>  2*X*A - X*X*A*A = 1
- *                   =>  2*(1) - (1)     = 1
+ * XA = 1 (mod 2**n)  =>  (X(2-XA)) A = 1 (mod 2**2n)
+ *                    =>  2*X*A - X*X*A*A = 1
+ *                    =>  2*(1) - (1)     = 1
  */
-  b = a->dp[0];
+  b = n->dp[0];
 
   if ((b & 1) == 0) {
     return MP_VAL;
   }
 
-  x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2^4 */
-  x *= 2 - b * x;               /* here x*a==1 mod 2^8 */
+  x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2**4 */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**8 */
 #if !defined(MP_8BIT)
-  x *= 2 - b * x;               /* here x*a==1 mod 2^16; each step doubles the nb of bits */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**16 */
 #endif
 #if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT))
-  x *= 2 - b * x;               /* here x*a==1 mod 2^32 */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**32 */
 #endif
 #ifdef MP_64BIT
-  x *= 2 - b * x;               /* here x*a==1 mod 2^64 */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**64 */
 #endif
 
-  /* t = -1/m mod b */
-  *mp = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
+  /* rho = -1/m mod b */
+  *rho = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
 
   return MP_OKAY;
 }
diff --git a/bn_mp_mul.c b/bn_mp_mul.c
index 258cb84..6b00235 100644
--- a/bn_mp_mul.c
+++ b/bn_mp_mul.c
@@ -20,19 +20,24 @@ mp_mul (mp_int * a, mp_int * b, mp_int * c)
 {
   int     res, neg;
   neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
-  if (MIN (a->used, b->used) > KARATSUBA_MUL_CUTOFF) {
+  
+  if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) {
+    res = mp_toom_mul(a, b, c);
+  } else if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) {
     res = mp_karatsuba_mul (a, b, c);
   } else {
 
     /* can we use the fast multiplier?
      *
-     * The fast multiplier can be used if the output will have less than
-     * MP_WARRAY digits and the number of digits won't affect carry propagation
+     * The fast multiplier can be used if the output will 
+     * have less than MP_WARRAY digits and the number of 
+     * digits won't affect carry propagation
      */
     int     digs = a->used + b->used + 1;
 
-    if ((digs < MP_WARRAY)
-        && MIN(a->used, b->used) <= (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
+    if ((digs < MP_WARRAY) &&
+        MIN(a->used, b->used) <= 
+        (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
       res = fast_s_mp_mul_digs (a, b, c, digs);
     } else {
       res = s_mp_mul (a, b, c);
diff --git a/bn_mp_reduce.c b/bn_mp_reduce.c
index d98dc08..4634c70 100644
--- a/bn_mp_reduce.c
+++ b/bn_mp_reduce.c
@@ -14,22 +14,8 @@
  */
 #include <tommath.h>
 
-/* pre-calculate the value required for Barrett reduction
- * For a given modulus "b" it calulates the value required in "a"
- */
-int
-mp_reduce_setup (mp_int * a, mp_int * b)
-{
-  int     res;
-  
-  if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) {
-    return res;
-  }
-  res = mp_div (a, b, a, NULL);
-  return res;
-}
-
-/* reduces x mod m, assumes 0 < x < m^2, mu is precomputed via mp_reduce_setup
+/* reduces x mod m, assumes 0 < x < m**2, mu is 
+ * precomputed via mp_reduce_setup.
  * From HAC pp.604 Algorithm 14.42
  */
 int
@@ -38,11 +24,12 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
   mp_int  q;
   int     res, um = m->used;
 
+  /* q = x */
   if ((res = mp_init_copy (&q, x)) != MP_OKAY) {
     return res;
   }
 
-  /* q1 = x / b^(k-1)  */
+  /* q1 = x / b**(k-1)  */
   mp_rshd (&q, um - 1);         
 
   /* according to HAC this is optimization is ok */
@@ -56,15 +43,15 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
     }
   }
 
-  /* q3 = q2 / b^(k+1) */
+  /* q3 = q2 / b**(k+1) */
   mp_rshd (&q, um + 1);         
 
-  /* x = x mod b^(k+1), quick (no division) */
+  /* x = x mod b**(k+1), quick (no division) */
   if ((res = mp_mod_2d (x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) {
     goto CLEANUP;
   }
 
-  /* q = q * m mod b^(k+1), quick (no division) */
+  /* q = q * m mod b**(k+1), quick (no division) */
   if ((res = s_mp_mul_digs (&q, m, &q, um + 1)) != MP_OKAY) {
     goto CLEANUP;
   }
@@ -74,7 +61,7 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
     goto CLEANUP;
   }
 
-  /* If x < 0, add b^(k+1) to it */
+  /* If x < 0, add b**(k+1) to it */
   if (mp_cmp_d (x, 0) == MP_LT) {
     mp_set (&q, 1);
     if ((res = mp_lshd (&q, um + 1)) != MP_OKAY)
@@ -89,7 +76,7 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
       break;
     }
   }
-
+  
 CLEANUP:
   mp_clear (&q);
 
diff --git a/bn_mp_reduce_2k.c b/bn_mp_reduce_2k.c
new file mode 100644
index 0000000..91d5f6f
--- /dev/null
+++ b/bn_mp_reduce_2k.c
@@ -0,0 +1,56 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* reduces a modulo n where n is of the form 2**p - k */
+int
+mp_reduce_2k(mp_int *a, mp_int *n, mp_digit k)
+{
+   mp_int q;
+   int    p, res;
+   
+   if ((res = mp_init(&q)) != MP_OKAY) {
+      return res;
+   }
+   
+   p = mp_count_bits(n);    
+top:
+   /* q = a/2**p, a = a mod 2**p */
+   if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) {
+      goto ERR;
+   }
+   
+   if (k != 1) {
+      /* q = q * k */
+      if ((res = mp_mul_d(&q, k, &q)) != MP_OKAY) { 
+         goto ERR;
+      }
+   }
+   
+   /* a = a + q */
+   if ((res = s_mp_add(a, &q, a)) != MP_OKAY) {
+      goto ERR;
+   }
+   
+   if (mp_cmp_mag(a, n) != MP_LT) {
+      s_mp_sub(a, n, a);
+      goto top;
+   }
+   
+ERR:
+   mp_clear(&q);
+   return res;
+}
+
diff --git a/bn_mp_reduce_2k_setup.c b/bn_mp_reduce_2k_setup.c
new file mode 100644
index 0000000..7308c32
--- /dev/null
+++ b/bn_mp_reduce_2k_setup.c
@@ -0,0 +1,42 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* determines the setup value */
+int 
+mp_reduce_2k_setup(mp_int *a, mp_digit *d)
+{
+   int res, p;
+   mp_int tmp;
+   
+   if ((res = mp_init(&tmp)) != MP_OKAY) {
+      return res;
+   }
+   
+   p = mp_count_bits(a);
+   if ((res = mp_2expt(&tmp, p)) != MP_OKAY) {
+      mp_clear(&tmp);
+      return res;
+   }
+   
+   if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) {
+      mp_clear(&tmp);
+      return res;
+   }
+   
+   *d = tmp.dp[0];
+   mp_clear(&tmp);
+   return MP_OKAY;
+}
diff --git a/bn_mp_reduce_is_2k.c b/bn_mp_reduce_is_2k.c
new file mode 100644
index 0000000..7d1666d
--- /dev/null
+++ b/bn_mp_reduce_is_2k.c
@@ -0,0 +1,37 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* determines if mp_reduce_2k can be used */
+int 
+mp_reduce_is_2k(mp_int *a)
+{
+   int ix, iy;
+   
+   if (a->used == 0) {
+      return 0;
+   } else if (a->used == 1) {
+      return 1;
+   } else if (a->used > 1) {
+      iy = mp_count_bits(a);
+      for (ix = DIGIT_BIT; ix < iy; ix++) {
+          if ((a->dp[ix/DIGIT_BIT] & ((mp_digit)1 << (mp_digit)(ix % DIGIT_BIT))) == 0) {
+             return 0;
+          }
+      }
+   }
+   return 1;
+}
+
diff --git a/bn_mp_reduce_setup.c b/bn_mp_reduce_setup.c
new file mode 100644
index 0000000..6f2b8eb
--- /dev/null
+++ b/bn_mp_reduce_setup.c
@@ -0,0 +1,29 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* pre-calculate the value required for Barrett reduction
+ * For a given modulus "b" it calulates the value required in "a"
+ */
+int
+mp_reduce_setup (mp_int * a, mp_int * b)
+{
+  int     res;
+  
+  if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) {
+    return res;
+  }
+  return mp_div (a, b, a, NULL);
+}
diff --git a/bn_mp_rshd.c b/bn_mp_rshd.c
index a703dda..f657ec0 100644
--- a/bn_mp_rshd.c
+++ b/bn_mp_rshd.c
@@ -32,15 +32,15 @@ mp_rshd (mp_int * a, int b)
   }
 
   {
-    register mp_digit *tmpa, *tmpaa;
+    register mp_digit *bottom, *top;
 
     /* shift the digits down */
 
-    /* base */
-    tmpa = a->dp;
+    /* bottom */
+    bottom = a->dp;
 
-    /* offset into digits */
-    tmpaa = a->dp + b;
+    /* top [offset into digits] */
+    top = a->dp + b;
 
     /* this is implemented as a sliding window where 
      * the window is b-digits long and digits from 
@@ -53,13 +53,15 @@ mp_rshd (mp_int * a, int b)
                   \-------------------/      ---->
      */
     for (x = 0; x < (a->used - b); x++) {
-      *tmpa++ = *tmpaa++;
+      *bottom++ = *top++;
     }
 
     /* zero the top digits */
     for (; x < a->used; x++) {
-      *tmpa++ = 0;
+      *bottom++ = 0;
     }
   }
-  mp_clamp (a);
+  
+  /* remove excess digits */
+  a->used -= b;
 }
diff --git a/bn_mp_set_int.c b/bn_mp_set_int.c
index 69a55a8..a9a37f1 100644
--- a/bn_mp_set_int.c
+++ b/bn_mp_set_int.c
@@ -35,7 +35,7 @@ mp_set_int (mp_int * a, unsigned int b)
     b <<= 4;
 
     /* ensure that digits are not clamped off */
-    a->used += 32 / DIGIT_BIT + 2;
+    a->used += 1;
   }
   mp_clamp (a);
   return MP_OKAY;
diff --git a/bn_mp_sqr.c b/bn_mp_sqr.c
index c530c9a..77539fc 100644
--- a/bn_mp_sqr.c
+++ b/bn_mp_sqr.c
@@ -19,12 +19,16 @@ int
 mp_sqr (mp_int * a, mp_int * b)
 {
   int     res;
-  if (a->used > KARATSUBA_SQR_CUTOFF) {
+  if (a->used >= TOOM_SQR_CUTOFF) {
+    res = mp_toom_sqr(a, b);
+  } else if (a->used >= KARATSUBA_SQR_CUTOFF) {
     res = mp_karatsuba_sqr (a, b);
   } else {
 
     /* can we use the fast multiplier? */
-    if ((a->used * 2 + 1) < 512 && a->used < (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) {
+    if ((a->used * 2 + 1) < MP_WARRAY && 
+         a->used < 
+         (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) {
       res = fast_s_mp_sqr (a, b);
     } else {
       res = s_mp_sqr (a, b);
diff --git a/bn_mp_toom_mul.c b/bn_mp_toom_mul.c
new file mode 100644
index 0000000..12fbc66
--- /dev/null
+++ b/bn_mp_toom_mul.c
@@ -0,0 +1,268 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* multiplication using Toom-Cook 3-way algorithm */
+int 
+mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
+{
+    mp_int w0, w1, w2, w3, w4, tmp1, tmp2, a0, a1, a2, b0, b1, b2;
+    int res, B;
+        
+    /* init temps */
+    if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &b0, &b1, &b2, &tmp1, &tmp2, NULL)) != MP_OKAY) {
+       return res;
+    }
+    
+    /* B */
+    B = MIN(a->used, b->used) / 3;
+    
+    /* a = a2 * B^2 + a1 * B + a0 */
+    if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) {
+       goto ERR;
+    }
+
+    if ((res = mp_copy(a, &a1)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a1, B);
+    mp_mod_2d(&a1, DIGIT_BIT * B, &a1);
+
+    if ((res = mp_copy(a, &a2)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a2, B*2);
+    
+    /* b = b2 * B^2 + b1 * B + b0 */
+    if ((res = mp_mod_2d(b, DIGIT_BIT * B, &b0)) != MP_OKAY) {
+       goto ERR;
+    }
+
+    if ((res = mp_copy(b, &b1)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&b1, B);
+    mp_mod_2d(&b1, DIGIT_BIT * B, &b1);
+
+    if ((res = mp_copy(b, &b2)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&b2, B*2);
+    
+    /* w0 = a0*b0 */
+    if ((res = mp_mul(&a0, &b0, &w0)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w4 = a2 * b2 */
+    if ((res = mp_mul(&a2, &b2, &w4)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w1 = (a2 + 2(a1 + 2a0))(b2 + 2(b1 + 2b0)) */
+    if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul_2(&b0, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul(&tmp1, &tmp2, &w1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w3 = (a0 + 2(a1 + 2a2))(b0 + 2(b1 + 2b2)) */
+    if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul_2(&b2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul(&tmp1, &tmp2, &w3)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+
+    /* w2 = (a2 + a1 + a0)(b2 + b1 + b0) */
+    if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&b2, &b1, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul(&tmp1, &tmp2, &w2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* now solve the matrix 
+    
+       0  0  0  0  1
+       1  2  4  8  16
+       1  1  1  1  1
+       16 8  4  2  1
+       1  0  0  0  0
+       
+       using 12 subtractions, 4 shifts, 2 small divisions and 1 small multiplication 
+     */
+     
+     /* r1 - r4 */
+     if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r0 */
+     if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/2 */
+     if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/2 */
+     if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r2 - r0 - r4 */
+     if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - 8r0 */
+     if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - 8r4 */
+     if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* 3r2 - r1 - r3 */
+     if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/3 */
+     if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/3 */
+     if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     
+     /* at this point shift W[n] by B*n */
+     if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+     if ((res = mp_add(&w0, &w1, c)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&tmp1, c, c)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+ERR:
+     mp_clear_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &b0, &b1, &b2, &tmp1, &tmp2, NULL);
+     return res;
+}     
+     
diff --git a/bn_mp_toom_sqr.c b/bn_mp_toom_sqr.c
new file mode 100644
index 0000000..bccf709
--- /dev/null
+++ b/bn_mp_toom_sqr.c
@@ -0,0 +1,220 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* squaring using Toom-Cook 3-way algorithm */
+int 
+mp_toom_sqr(mp_int *a, mp_int *b)
+{
+    mp_int w0, w1, w2, w3, w4, tmp1, a0, a1, a2;
+    int res, B;
+        
+    /* init temps */
+    if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL)) != MP_OKAY) {
+       return res;
+    }
+
+    /* B */
+    B = a->used / 3;
+    
+    /* a = a2 * B^2 + a1 * B + a0 */
+    if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) {
+       goto ERR;
+    }
+
+    if ((res = mp_copy(a, &a1)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a1, B);
+    mp_mod_2d(&a1, DIGIT_BIT * B, &a1);
+
+    if ((res = mp_copy(a, &a2)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a2, B*2);
+        
+    /* w0 = a0*a0 */
+    if ((res = mp_sqr(&a0, &w0)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w4 = a2 * a2 */
+    if ((res = mp_sqr(&a2, &w4)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w1 = (a2 + 2(a1 + 2a0))**2 */
+    if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_sqr(&tmp1, &w1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w3 = (a0 + 2(a1 + 2a2))**2 */
+    if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_sqr(&tmp1, &w3)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+
+    /* w2 = (a2 + a1 + a0)**2 */
+    if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_sqr(&tmp1, &w2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* now solve the matrix 
+    
+       0  0  0  0  1
+       1  2  4  8  16
+       1  1  1  1  1
+       16 8  4  2  1
+       1  0  0  0  0
+       
+       using 12 subtractions, 4 shifts, 2 small divisions and 1 small multiplication.
+     */
+     
+     /* r1 - r4 */
+     if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r0 */
+     if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/2 */
+     if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/2 */
+     if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r2 - r0 - r4 */
+     if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - 8r0 */
+     if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - 8r4 */
+     if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* 3r2 - r1 - r3 */
+     if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/3 */
+     if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/3 */
+     if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     
+     /* at this point shift W[n] by B*n */
+     if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+     if ((res = mp_add(&w0, &w1, b)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&tmp1, b, b)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+ERR:
+     mp_clear_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL);
+     return res;
+}     
+     
diff --git a/bn_s_mp_add.c b/bn_s_mp_add.c
index 87aab4e..cf677d8 100644
--- a/bn_s_mp_add.c
+++ b/bn_s_mp_add.c
@@ -45,7 +45,6 @@ s_mp_add (mp_int * a, mp_int * b, mp_int * c)
   olduse = c->used;
   c->used = max + 1;
 
-  /* set the carry to zero */
   {
     register mp_digit u, *tmpa, *tmpb, *tmpc;
     register int i;
diff --git a/bn_s_mp_exptmod.c b/bn_s_mp_exptmod.c
new file mode 100644
index 0000000..7590a51
--- /dev/null
+++ b/bn_s_mp_exptmod.c
@@ -0,0 +1,211 @@
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+int
+s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
+{
+  mp_int  M[256], res, mu;
+  mp_digit buf;
+  int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
+
+  /* find window size */
+  x = mp_count_bits (X);
+  if (x <= 7) {
+    winsize = 2;
+  } else if (x <= 36) {
+    winsize = 3;
+  } else if (x <= 140) {
+    winsize = 4;
+  } else if (x <= 450) {
+    winsize = 5;
+  } else if (x <= 1303) {
+    winsize = 6;
+  } else if (x <= 3529) {
+    winsize = 7;
+  } else {
+    winsize = 8;
+  }
+
+#ifdef MP_LOW_MEM
+    if (winsize > 5) {
+       winsize = 5;
+    }
+#endif
+
+  /* init M array */
+  for (x = 0; x < (1 << winsize); x++) {
+    if ((err = mp_init_size (&M[x], 1)) != MP_OKAY) {
+      for (y = 0; y < x; y++) {
+        mp_clear (&M[y]);
+      }
+      return err;
+    }
+  }
+
+  /* create mu, used for Barrett reduction */
+  if ((err = mp_init (&mu)) != MP_OKAY) {
+    goto __M;
+  }
+  if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) {
+    goto __MU;
+  }
+
+  /* create M table
+   *
+   * The M table contains powers of the input base, e.g. M[x] = G**x mod P
+   *
+   * The first half of the table is not computed though accept for M[0] and M[1]
+   */
+  if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) {
+    goto __MU;
+  }
+
+  /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */
+  if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
+    goto __MU;
+  }
+
+  for (x = 0; x < (winsize - 1); x++) {
+    if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
+      goto __MU;
+    }
+    if ((err = mp_reduce (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) {
+      goto __MU;
+    }
+  }
+
+  /* create upper table */
+  for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
+    if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
+      goto __MU;
+    }
+    if ((err = mp_reduce (&M[x], P, &mu)) != MP_OKAY) {
+      goto __MU;
+    }
+  }
+
+  /* setup result */
+  if ((err = mp_init (&res)) != MP_OKAY) {
+    goto __MU;
+  }
+  mp_set (&res, 1);
+
+  /* set initial mode and bit cnt */
+  mode   = 0;
+  bitcnt = 1;
+  buf    = 0;
+  digidx = X->used - 1;
+  bitcpy = 0;
+  bitbuf = 0;
+
+  for (;;) {
+    /* grab next digit as required */
+    if (--bitcnt == 0) {
+      if (digidx == -1) {
+        break;
+      }
+      buf = X->dp[digidx--];
+      bitcnt = (int) DIGIT_BIT;
+    }
+
+    /* grab the next msb from the exponent */
+    y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
+    buf <<= (mp_digit)1;
+
+    /* if the bit is zero and mode == 0 then we ignore it
+     * These represent the leading zero bits before the first 1 bit
+     * in the exponent.  Technically this opt is not required but it
+     * does lower the # of trivial squaring/reductions used
+     */
+    if (mode == 0 && y == 0)
+      continue;
+
+    /* if the bit is zero and mode == 1 then we square */
+    if (mode == 1 && y == 0) {
+      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
+        goto __RES;
+      }
+      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+        goto __RES;
+      }
+      continue;
+    }
+
+    /* else we add it to the window */
+    bitbuf |= (y << (winsize - ++bitcpy));
+    mode = 2;
+
+    if (bitcpy == winsize) {
+      /* ok window is filled so square as required and multiply  */
+      /* square first */
+      for (x = 0; x < winsize; x++) {
+        if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
+          goto __RES;
+        }
+        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+          goto __RES;
+        }
+      }
+
+      /* then multiply */
+      if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) {
+        goto __MU;
+      }
+      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+        goto __MU;
+      }
+
+      /* empty window and reset */
+      bitcpy = 0;
+      bitbuf = 0;
+      mode = 1;
+    }
+  }
+
+  /* if bits remain then square/multiply */
+  if (mode == 2 && bitcpy > 0) {
+    /* square then multiply if the bit is set */
+    for (x = 0; x < bitcpy; x++) {
+      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
+        goto __RES;
+      }
+      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+        goto __RES;
+      }
+
+      bitbuf <<= 1;
+      if ((bitbuf & (1 << winsize)) != 0) {
+        /* then multiply */
+        if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) {
+          goto __RES;
+        }
+        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+          goto __RES;
+        }
+      }
+    }
+  }
+
+  mp_exch (&res, Y);
+  err = MP_OKAY;
+__RES:mp_clear (&res);
+__MU:mp_clear (&mu);
+__M:
+  for (x = 0; x < (1 << winsize); x++) {
+    mp_clear (&M[x]);
+  }
+  return err;
+}
diff --git a/bn_s_mp_sqr.c b/bn_s_mp_sqr.c
index fcb2767..e153250 100644
--- a/bn_s_mp_sqr.c
+++ b/bn_s_mp_sqr.c
@@ -20,8 +20,8 @@ s_mp_sqr (mp_int * a, mp_int * b)
 {
   mp_int  t;
   int     res, ix, iy, pa;
-  mp_word r, u;
-  mp_digit tmpx, *tmpt;
+  mp_word r;
+  mp_digit u, tmpx, *tmpt;
 
   pa = a->used;
   if ((res = mp_init_size (&t, pa + pa + 1)) != MP_OKAY) {
@@ -32,7 +32,8 @@ s_mp_sqr (mp_int * a, mp_int * b)
   for (ix = 0; ix < pa; ix++) {
     /* first calculate the digit at 2*ix */
     /* calculate double precision result */
-    r = ((mp_word) t.dp[ix + ix]) + ((mp_word) a->dp[ix]) * ((mp_word) a->dp[ix]);
+    r = ((mp_word) t.dp[ix + ix]) + 
+        ((mp_word) a->dp[ix]) * ((mp_word) a->dp[ix]);
 
     /* store lower part in result */
     t.dp[ix + ix] = (mp_digit) (r & ((mp_word) MP_MASK));
@@ -44,7 +45,8 @@ s_mp_sqr (mp_int * a, mp_int * b)
     tmpx = a->dp[ix];
 
     /* alias for where to store the results */
-    tmpt = &(t.dp[ix + ix + 1]);
+    tmpt = t.dp + (ix + ix + 1);
+    
     for (iy = ix + 1; iy < pa; iy++) {
       /* first calculate the product */
       r = ((mp_word) tmpx) * ((mp_word) a->dp[iy]);
@@ -60,13 +62,9 @@ s_mp_sqr (mp_int * a, mp_int * b)
       /* get carry */
       u = (r >> ((mp_word) DIGIT_BIT));
     }
-    r = ((mp_word) * tmpt) + u;
-    *tmpt = (mp_digit) (r & ((mp_word) MP_MASK));
-    u = (r >> ((mp_word) DIGIT_BIT));
     /* propagate upwards */
-    ++tmpt;
-    while (u != ((mp_word) 0)) {
-      r = ((mp_word) * tmpt) + ((mp_word) 1);
+    while (u != ((mp_digit) 0)) {
+      r = ((mp_word) * tmpt) + ((mp_word) u);
       *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
       u = (r >> ((mp_word) DIGIT_BIT));
     }
diff --git a/bn_s_mp_sub.c b/bn_s_mp_sub.c
index 5f22999..32a01d9 100644
--- a/bn_s_mp_sub.c
+++ b/bn_s_mp_sub.c
@@ -33,7 +33,6 @@ s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
   olduse = c->used;
   c->used = max;
 
-  /* sub digits from lower part */
   {
     register mp_digit u, *tmpa, *tmpb, *tmpc;
     register int i;
@@ -52,7 +51,7 @@ s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
       /* U = carry bit of T[i]
        * Note this saves performing an AND operation since
        * if a carry does occur it will propagate all the way to the
-       * MSB.  As a result a single shift is required to get the carry
+       * MSB.  As a result a single shift is enough to get the carry
        */
       u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
 
@@ -81,3 +80,4 @@ s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
   mp_clamp (c);
   return MP_OKAY;
 }
+
diff --git a/bncore.c b/bncore.c
index 7e7ac50..8ca206a 100644
--- a/bncore.c
+++ b/bncore.c
@@ -18,11 +18,14 @@
 
  CPU                    /Compiler     /MUL CUTOFF/SQR CUTOFF
 -------------------------------------------------------------
- Intel P4               /GCC v3.2     /        81/       110
+ Intel P4               /GCC v3.2     /        70/       108
  AMD Athlon XP          /GCC v3.2     /       109/       127
 
 */
 
 /* configured for a AMD XP Thoroughbred core with etc/tune.c */
 int     KARATSUBA_MUL_CUTOFF = 109,      /* Min. number of digits before Karatsuba multiplication is used. */
-        KARATSUBA_SQR_CUTOFF = 127;      /* Min. number of digits before Karatsuba squaring is used. */
+        KARATSUBA_SQR_CUTOFF = 127,      /* Min. number of digits before Karatsuba squaring is used. */
+        
+        TOOM_MUL_CUTOFF      = 350,      /* no optimal values of these are known yet so set em high */
+        TOOM_SQR_CUTOFF      = 400; 
diff --git a/changes.txt b/changes.txt
index 997774e..9c8df6d 100644
--- a/changes.txt
+++ b/changes.txt
@@ -1,3 +1,15 @@
+May 29th, 2003
+v0.18  -- Fixed a bug in s_mp_sqr which would handle carries properly just not very elegantly.
+          (e.g. correct result, just bad looking code)
+       -- Fixed bug in mp_sqr which still had a 512 constant instead of MP_WARRAY
+       -- Added Toom-Cook multipliers [needs tuning!]
+       -- Added efficient divide by 3 algorithm mp_div_3
+       -- Re-wrote mp_div_d to be faster than calling mp_div 
+       -- Added in a donated BCC makefile and a single page LTM poster (ahalhabsi@sbcglobal.net)
+       -- Added mp_reduce_2k which reduces an input modulo n = 2**p - k for any single digit k
+       -- Made the exptmod system be aware of the 2k reduction algorithms.
+       -- Rewrote mp_dr_reduce to be smaller, simpler and easier to understand.
+
 May 17th, 2003
 v0.17  -- Benjamin Goldberg submitted optimized mp_add and mp_sub routines.  A new gen.pl as well
           as several smaller suggestions.  Thanks!
diff --git a/demo/demo.c b/demo/demo.c
index ab8794d..36544fd 100644
--- a/demo/demo.c
+++ b/demo/demo.c
@@ -53,7 +53,7 @@ int main(void)
 #ifdef TIMER
    int n;
    ulong64 tt;
-   FILE *log, *logb;
+   FILE *log, *logb, *logc;
 #endif
 
    mp_init(&a);
@@ -62,11 +62,54 @@ int main(void)
    mp_init(&d);
    mp_init(&e);
    mp_init(&f);   
+   
+   srand(time(NULL));
+/* test mp_reduce_2k */
+#if 0
+   for (cnt = 3; cnt <= 4096; ++cnt) {
+       mp_digit tmp;
+       mp_2expt(&a, cnt);
+       mp_sub_d(&a, 1, &a);  /* a = 2**cnt - 1 */
+       
+       
+       printf("\nTesting %4d bits", cnt);
+       printf("(%d)", mp_reduce_is_2k(&a));
+       mp_reduce_2k_setup(&a, &tmp);
+       printf("(%d)", tmp);
+       for (ix = 0; ix < 100000; ix++) {
+           if (!(ix & 1023)) {printf("."); fflush(stdout); }
+           mp_rand(&b, (cnt/DIGIT_BIT  + 1) * 2);
+           mp_copy(&c, &b);
+           mp_mod(&c, &a, &c);
+           mp_reduce_2k(&b, &a, 1);
+           if (mp_cmp(&c, &b)) {
+              printf("FAILED\n");
+              exit(0);
+           }
+        }
+    }
+#endif
+
+           
+/* test mp_div_3  */
+#if 0
+   for (cnt = 0; cnt < 1000000; ) {
+      mp_digit r1, r2;
+      
+      if (!(++cnt & 127)) printf("%9d\r", cnt);
+      mp_rand(&a, abs(rand()) % 32 + 1);
+      mp_div_d(&a, 3, &b, &r1);
+      mp_div_3(&a, &c, &r2);
+      
+      if (mp_cmp(&b, &c) || r1 != r2) {
+         printf("Failure\n");
+      }
+   }
+#endif     
 
 /* test the DR reduction */
 #if 0
 
-   srand(time(NULL));
    for (cnt = 2; cnt < 32; cnt++) {
        printf("%d digit modulus\n", cnt);
        mp_grow(&a, cnt);
@@ -91,6 +134,7 @@ int main(void)
 
          if (mp_cmp(&b, &c) != MP_EQ) {
             printf("Failed on trial %lu\n", rr); exit(-1);
+                       
          }
       } while (++rr < 1000000);
       printf("Passed DR test for %d digits\n", cnt);
@@ -98,6 +142,9 @@ int main(void)
 #endif
 
 #ifdef TIMER
+      /* temp. turn off TOOM */
+      TOOM_MUL_CUTOFF = TOOM_SQR_CUTOFF = 100000;
+          
       printf("CLOCKS_PER_SEC == %lu\n", CLOCKS_PER_SEC);
 
       log = fopen("logs/add.log", "w");
@@ -172,9 +219,16 @@ int main(void)
       }
       fclose(log);
    }
-
-   {
+  {
       char *primes[] = {
+         /* 2K moduli mersenne primes */
+         "6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151",
+         "531137992816767098689588206552468627329593117727031923199444138200403559860852242739162502265229285668889329486246501015346579337652707239409519978766587351943831270835393219031728127",
+         "10407932194664399081925240327364085538615262247266704805319112350403608059673360298012239441732324184842421613954281007791383566248323464908139906605677320762924129509389220345773183349661583550472959420547689811211693677147548478866962501384438260291732348885311160828538416585028255604666224831890918801847068222203140521026698435488732958028878050869736186900714720710555703168729087",
+         "1475979915214180235084898622737381736312066145333169775147771216478570297878078949377407337049389289382748507531496480477281264838760259191814463365330269540496961201113430156902396093989090226259326935025281409614983499388222831448598601834318536230923772641390209490231836446899608210795482963763094236630945410832793769905399982457186322944729636418890623372171723742105636440368218459649632948538696905872650486914434637457507280441823676813517852099348660847172579408422316678097670224011990280170474894487426924742108823536808485072502240519452587542875349976558572670229633962575212637477897785501552646522609988869914013540483809865681250419497686697771007",
+         "259117086013202627776246767922441530941818887553125427303974923161874019266586362086201209516800483406550695241733194177441689509238807017410377709597512042313066624082916353517952311186154862265604547691127595848775610568757931191017711408826252153849035830401185072116424747461823031471398340229288074545677907941037288235820705892351068433882986888616658650280927692080339605869308790500409503709875902119018371991620994002568935113136548829739112656797303241986517250116412703509705427773477972349821676443446668383119322540099648994051790241624056519054483690809616061625743042361721863339415852426431208737266591962061753535748892894599629195183082621860853400937932839420261866586142503251450773096274235376822938649407127700846077124211823080804139298087057504713825264571448379371125032081826126566649084251699453951887789613650248405739378594599444335231188280123660406262468609212150349937584782292237144339628858485938215738821232393687046160677362909315071",
+         "190797007524439073807468042969529173669356994749940177394741882673528979787005053706368049835514900244303495954950709725762186311224148828811920216904542206960744666169364221195289538436845390250168663932838805192055137154390912666527533007309292687539092257043362517857366624699975402375462954490293259233303137330643531556539739921926201438606439020075174723029056838272505051571967594608350063404495977660656269020823960825567012344189908927956646011998057988548630107637380993519826582389781888135705408653045219655801758081251164080554609057468028203308718724654081055323215860189611391296030471108443146745671967766308925858547271507311563765171008318248647110097614890313562856541784154881743146033909602737947385055355960331855614540900081456378659068370317267696980001187750995491090350108417050917991562167972281070161305972518044872048331306383715094854938415738549894606070722584737978176686422134354526989443028353644037187375385397838259511833166416134323695660367676897722287918773420968982326089026150031515424165462111337527431154890666327374921446276833564519776797633875503548665093914556482031482248883127023777039667707976559857333357013727342079099064400455741830654320379350833236245819348824064783585692924881021978332974949906122664421376034687815350484991",
+         
          /* DR moduli */
          "14059105607947488696282932836518693308967803494693489478439861164411992439598399594747002144074658928593502845729752797260025831423419686528151609940203368612079",
          "101745825697019260773923519755878567461315282017759829107608914364075275235254395622580447400994175578963163918967182013639660669771108475957692810857098847138903161308502419410142185759152435680068435915159402496058513611411688900243039",
@@ -196,6 +250,7 @@ int main(void)
       };
    log = fopen("logs/expt.log", "w");
    logb = fopen("logs/expt_dr.log", "w");
+   logc = fopen("logs/expt_2k.log", "w");
    for (n = 0; primes[n]; n++) {
       mp_read_radix(&a, primes[n], 10);
       mp_zero(&b);
@@ -224,11 +279,12 @@ int main(void)
          exit(0);
       }
       printf("Exponentiating\t%4d-bit => %9llu/sec, %9llu ticks\n", mp_count_bits(&a), (((unsigned long long)rr)*CLOCKS_PER_SEC)/tt, tt);
-      fprintf((n < 7) ? logb : log, "%d %9llu\n", mp_count_bits(&a), (((unsigned long long)rr)*CLOCKS_PER_SEC)/tt);
+      fprintf((n < 6) ? logc : (n < 13) ? logb : log, "%d %9llu\n", mp_count_bits(&a), (((unsigned long long)rr)*CLOCKS_PER_SEC)/tt);
    }
    }
    fclose(log);
    fclose(logb);
+   fclose(logc);
 
    log = fopen("logs/invmod.log", "w");
    for (cnt = 4; cnt <= 128; cnt += 4) {
@@ -263,6 +319,12 @@ int main(void)
 
    div2_n = mul2_n = inv_n = expt_n = lcm_n = gcd_n = add_n =
    sub_n = mul_n = div_n = sqr_n = mul2d_n = div2d_n = cnt = 0;
+   
+   /* force KARA and TOOM to enable despite cutoffs */
+   KARATSUBA_SQR_CUTOFF = KARATSUBA_MUL_CUTOFF = 110;
+   TOOM_SQR_CUTOFF      = TOOM_MUL_CUTOFF      = 150;
+   
+   
 
    for (;;) {
        /* randomly clear and re-init one variable, this has the affect of triming the alloc space */
diff --git a/etc/2kprime.1 b/etc/2kprime.1
new file mode 100644
index 0000000..eb12565
--- /dev/null
+++ b/etc/2kprime.1
@@ -0,0 +1,2 @@
+256-bits (k = 36113) = 115792089237316195423570985008687907853269984665640564039457584007913129603823
+512-bits (k = 38117) = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006045979
diff --git a/etc/2kprime.c b/etc/2kprime.c
new file mode 100644
index 0000000..47b0e1d
--- /dev/null
+++ b/etc/2kprime.c
@@ -0,0 +1,80 @@
+/* Makes safe primes of a 2k nature */
+#include <tommath.h>
+#include <time.h>
+
+int sizes[] = {256, 512, 768, 1024, 1536, 2048, 3072, 4096};
+
+int main(void)
+{
+   char buf[2000];
+   int x, y, t;
+   mp_int q, p;
+   FILE *out;
+   clock_t t1;
+   mp_digit z;
+   
+   mp_init_multi(&q, &p, NULL);
+   
+   out = fopen("2kprime.1", "w");
+   for (x = 0; x < (int)(sizeof(sizes) / sizeof(sizes[0])); x++) {
+   top:
+       mp_2expt(&q, sizes[x]);
+       mp_add_d(&q, 3, &q);
+       z = -3;
+       
+       t1 = clock();
+       for(;;) {
+         mp_sub_d(&q, 4, &q);
+         z += 4;
+
+         if (z > MP_MASK) {
+            printf("No primes of size %d found\n", sizes[x]);
+            break;
+         }
+         
+         if (clock() - t1 > CLOCKS_PER_SEC) { 
+            printf("."); fflush(stdout);
+//            sleep((clock() - t1 + CLOCKS_PER_SEC/2)/CLOCKS_PER_SEC);
+            t1 = clock();
+         }
+         
+         /* quick test on q */
+         mp_prime_is_prime(&q, 1, &y);
+         if (y == 0) {
+            continue;
+         }
+
+         /* find (q-1)/2 */
+         mp_sub_d(&q, 1, &p);
+         mp_div_2(&p, &p);
+         mp_prime_is_prime(&p, 3, &y);
+         if (y == 0) {
+            continue;
+         }
+
+         /* test on q */
+         mp_prime_is_prime(&q, 3, &y);
+         if (y == 0) {
+            continue;
+         }
+
+         break;
+       }
+       
+       if (y == 0) {
+          ++sizes[x];
+          goto top;
+       }
+       
+       mp_toradix(&q, buf, 10);
+       printf("\n\n%d-bits (k = %lu) = %s\n", sizes[x], z, buf);
+       fprintf(out, "%d-bits (k = %lu) = %s\n", sizes[x], z, buf); fflush(out);
+   }
+   
+   return 0;
+}   
+       
+         
+            
+            
+          
diff --git a/etc/makefile b/etc/makefile
index dce98da..eb732e3 100644
--- a/etc/makefile
+++ b/etc/makefile
@@ -32,9 +32,13 @@ mersenne: mersenne.o
 drprime: drprime.o
 	$(CC) drprime.o $(LIBNAME) -o drprime
 	
+# fines 2k safe primes for the given config
+2kprime: 2kprime.o
+	$(CC) 2kprime.o $(LIBNAME) -o 2kprime
+
 mont: mont.o
 	$(CC) mont.o $(LIBNAME) -o mont
 
         
 clean:
-	rm -f *.log *.o *.obj *.exe pprime tune mersenne drprime tune86 tune86l mont
\ No newline at end of file
+	rm -f *.log *.o *.obj *.exe pprime tune mersenne drprime tune86 tune86l mont 2kprime
\ No newline at end of file
diff --git a/etc/makefile.msvc b/etc/makefile.msvc
index 06a95e2..e9fe6a2 100644
--- a/etc/makefile.msvc
+++ b/etc/makefile.msvc
@@ -14,4 +14,7 @@ tune: tune.obj
 	cl tune.obj ../tommath.lib
 	
 drprime: drprime.obj
-	cl drprime.obj ../tommath.lib
\ No newline at end of file
+	cl drprime.obj ../tommath.lib
+
+2kprime: 2kprime.obj
+	cl 2kprime.obj ../tommath.lib
diff --git a/etc/mersenne.c b/etc/mersenne.c
index fa6a856..b3ed715 100644
--- a/etc/mersenne.c
+++ b/etc/mersenne.c
@@ -8,10 +8,9 @@
 int
 is_mersenne (long s, int *pp)
 {
-  mp_int  n, u, mu;
+  mp_int  n, u;
   int     res, k;
-  long    ss;
-
+  
   *pp = 0;
 
   if ((res = mp_init (&n)) != MP_OKAY) {
@@ -22,27 +21,14 @@ is_mersenne (long s, int *pp)
     goto __N;
   }
 
-  if ((res = mp_init (&mu)) != MP_OKAY) {
-    goto __U;
-  }
-
   /* n = 2^s - 1 */
-  mp_set (&n, 1);
-  ss = s;
-  while (ss--) {
-    if ((res = mp_mul_2 (&n, &n)) != MP_OKAY) {
-      goto __MU;
-    }
+  if ((res = mp_2expt(&n, s)) != MP_OKAY) {
+     goto __MU;
   }
   if ((res = mp_sub_d (&n, 1, &n)) != MP_OKAY) {
     goto __MU;
   }
 
-  /* setup mu */
-  if ((res = mp_reduce_setup (&mu, &n)) != MP_OKAY) {
-    goto __MU;
-  }
-
   /* set u=4 */
   mp_set (&u, 4);
 
@@ -57,26 +43,26 @@ is_mersenne (long s, int *pp)
     }
 
     /* make sure u is positive */
-    if (u.sign == MP_NEG) {
+    while (u.sign == MP_NEG) {
       if ((res = mp_add (&u, &n, &u)) != MP_OKAY) {
-	goto __MU;
+         goto __MU;
       }
     }
 
     /* reduce */
-    if ((res = mp_reduce (&u, &n, &mu)) != MP_OKAY) {
+    if ((res = mp_reduce_2k (&u, &n, 1)) != MP_OKAY) {
       goto __MU;
     }
   }
 
   /* if u == 0 then its prime */
   if (mp_iszero (&u) == 1) {
-    *pp = 1;
+    mp_prime_is_prime(&n, 3, pp);
+  if (*pp != 1) printf("FAILURE\n");
   }
 
   res = MP_OKAY;
-__MU:mp_clear (&mu);
-__U:mp_clear (&u);
+__MU:mp_clear (&u);
 __N:mp_clear (&n);
   return res;
 }
diff --git a/etc/mont.c b/etc/mont.c
index af6fd7a..0de2084 100644
--- a/etc/mont.c
+++ b/etc/mont.c
@@ -7,10 +7,11 @@ int main(void)
    mp_digit mp;
    long x, y;
 
+   srand(time(NULL));
    mp_init_multi(&modulus, &R, &p, &pp, NULL);
 
    /* loop through various sizes */
-   for (x = 4; x < 128; x++) {
+   for (x = 4; x < 256; x++) {
        printf("DIGITS == %3ld...", x); fflush(stdout);
        
        /* make up the odd modulus */
@@ -22,7 +23,7 @@ int main(void)
        mp_montgomery_setup(&modulus, &mp);
        
        /* now run through a bunch tests */
-       for (y = 0; y < 100000; y++) {
+       for (y = 0; y < 1000; y++) {
            mp_rand(&p, x/2);        /* p = random */
            mp_mul(&p, &R, &pp);     /* pp = R * p */
            mp_montgomery_reduce(&pp, &modulus, mp);
diff --git a/etc/tune.c b/etc/tune.c
index 5648496..f4565bb 100644
--- a/etc/tune.c
+++ b/etc/tune.c
@@ -8,17 +8,17 @@
 #ifndef X86_TIMER
 
 /* generic ISO C timer */
-unsigned long long __T;
+ulong64 __T;
 void t_start(void) { __T = clock(); }
-unsigned long long t_read(void) { return clock() - __T; }
+ulong64 t_read(void) { return clock() - __T; }
 
 #else
 extern void t_start(void);
-extern unsigned long long t_read(void);
+extern ulong64 t_read(void);
 #endif
 
-unsigned long long
-time_mult (void)
+ulong64
+time_mult (int max)
 {
   int     x, y;
   mp_int  a, b, c;
@@ -28,7 +28,7 @@ time_mult (void)
   mp_init (&c);
 
   t_start();
-  for (x = 32; x <= 288; x += 4) {
+  for (x = 32; x <= max; x += 4) {
     mp_rand (&a, x);
     mp_rand (&b, x);
     for (y = 0; y < 100; y++) {
@@ -41,8 +41,8 @@ time_mult (void)
   return t_read();
 }
 
-unsigned long long
-time_sqr (void)
+ulong64
+time_sqr (int max)
 {
   int     x, y;
   mp_int  a, b;
@@ -51,7 +51,7 @@ time_sqr (void)
   mp_init (&b);
 
   t_start();
-  for (x = 32; x <= 288; x += 4) {
+  for (x = 32; x <= max; x += 4) {
     mp_rand (&a, x);
     for (y = 0; y < 100; y++) {
       mp_sqr (&a, &b);
@@ -65,45 +65,85 @@ time_sqr (void)
 int
 main (void)
 {
-  int     best_mult, best_square;
-  unsigned long long best, ti;
+  int     best_kmult, best_tmult, best_ksquare, best_tsquare;
+  ulong64 best, ti;
   FILE   *log;
 
-  best_mult = best_square = 0;
+  best_kmult = best_ksquare = best_tmult = best_tsquare = 0;
   /* tune multiplication first */
+  
+  /* effectively turn TOOM off */
+  TOOM_SQR_CUTOFF = TOOM_MUL_CUTOFF = 100000;
+    
   log = fopen ("mult.log", "w");
   best = -1;
   for (KARATSUBA_MUL_CUTOFF = 8; KARATSUBA_MUL_CUTOFF <= 200; KARATSUBA_MUL_CUTOFF++) {
-    ti = time_mult ();
+    ti = time_mult (300);
     printf ("%4d : %9llu\r", KARATSUBA_MUL_CUTOFF, ti);
     fprintf (log, "%d, %llu\n", KARATSUBA_MUL_CUTOFF, ti);
     fflush (stdout);
     if (ti < best) {
       printf ("New best: %llu, %d         \n", ti, KARATSUBA_MUL_CUTOFF);
       best = ti;
-      best_mult = KARATSUBA_MUL_CUTOFF;
+      best_kmult = KARATSUBA_MUL_CUTOFF;
     }
   }
   fclose (log);
+  
   /* tune squaring */
   log = fopen ("sqr.log", "w");
   best = -1;
   for (KARATSUBA_SQR_CUTOFF = 8; KARATSUBA_SQR_CUTOFF <= 200; KARATSUBA_SQR_CUTOFF++) {
-    ti = time_sqr ();
+    ti = time_sqr (300);
     printf ("%4d : %9llu\r", KARATSUBA_SQR_CUTOFF, ti);
     fprintf (log, "%d, %llu\n", KARATSUBA_SQR_CUTOFF, ti);
     fflush (stdout);
     if (ti < best) {
       printf ("New best: %llu, %d         \n", ti, KARATSUBA_SQR_CUTOFF);
       best = ti;
-      best_square = KARATSUBA_SQR_CUTOFF;
+      best_ksquare = KARATSUBA_SQR_CUTOFF;
     }
   }
   fclose (log);
+  
+  KARATSUBA_MUL_CUTOFF = best_kmult;
+  KARATSUBA_SQR_CUTOFF = best_ksquare;
+    
+  /* tune TOOM mult */
+  log = fopen ("tmult.log", "w");
+  best = -1;
+  for (TOOM_MUL_CUTOFF = best_kmult*5; TOOM_MUL_CUTOFF <= 800; TOOM_MUL_CUTOFF++) {
+    ti = time_mult (1200);
+    printf ("%4d : %9llu\r", TOOM_MUL_CUTOFF, ti);
+    fprintf (log, "%d, %llu\n", TOOM_MUL_CUTOFF, ti);
+    fflush (stdout);
+    if (ti < best) {
+      printf ("New best: %llu, %d         \n", ti, TOOM_MUL_CUTOFF);
+      best = ti;
+      best_tmult = TOOM_MUL_CUTOFF;
+    }
+  }
+  fclose (log);   
+  
+  /* tune TOOM sqr */
+  log = fopen ("tsqr.log", "w");
+  best = -1;
+  for (TOOM_SQR_CUTOFF = best_ksquare*3; TOOM_SQR_CUTOFF <= 800; TOOM_SQR_CUTOFF++) {
+    ti = time_sqr (1200);
+    printf ("%4d : %9llu\r", TOOM_SQR_CUTOFF, ti);
+    fprintf (log, "%d, %llu\n", TOOM_SQR_CUTOFF, ti);
+    fflush (stdout);
+    if (ti < best) {
+      printf ("New best: %llu, %d         \n", ti, TOOM_SQR_CUTOFF);
+      best = ti;
+      best_tsquare = TOOM_SQR_CUTOFF;
+    }
+  }
+  fclose (log);   
 
   printf
-    ("\n\n\nKaratsuba Multiplier Cutoff: %d\nKaratsuba Squaring Cutoff: %d\n",
-     best_mult, best_square);
+    ("\n\n\nKaratsuba Multiplier Cutoff: %d\nKaratsuba Squaring Cutoff: %d\nToom Multiplier Cutoff: %d\nToom Squaring Cutoff: %d\n",
+     best_kmult, best_ksquare, best_tmult, best_tsquare);
 
   return 0;
 }
diff --git a/gen.pl b/gen.pl
index e6009d9..d822182 100644
--- a/gen.pl
+++ b/gen.pl
@@ -6,7 +6,7 @@
 use strict;
 
 open( OUT, ">mpi.c" ) or die "Couldn't open mpi.c for writing: $!";
-foreach my $filename (glob "bn_*.c") {
+foreach my $filename (glob "bn*.c") {
    open( SRC, "<$filename" ) or die "Couldn't open $filename for reading: $!";
    print OUT "/* Start: $filename */\n";
    print OUT qq[#line 0 "$filename"\n];
@@ -14,5 +14,5 @@ foreach my $filename (glob "bn_*.c") {
    print OUT "\n/* End: $filename */\n\n";
    close SRC or die "Error closing $filename after reading: $!";
 }
-print OUT "\b/* EOF */\n";
+print OUT "\n/* EOF */\n";
 close OUT or die "Error closing mpi.c after writing: $!";
\ No newline at end of file
diff --git a/logs/add.log b/logs/add.log
index 1e144e8..796ab48 100644
--- a/logs/add.log
+++ b/logs/add.log
@@ -1,16 +1,16 @@
-224  11039864
-448   9206336
-672   8178200
-896   7432176
-1120   6433264
-1344   5847056
-1568   5270184
-1792   4943416
-2016   4520016
-2240   4256168
-2464   3999224
-2688   3714896
-2912   3572720
-3136   3340176
-3360   3222584
-3584   3036336
+224  11069160
+448   9156136
+672   8089755
+896   7399424
+1120   6389352
+1344   5818648
+1568   5257112
+1792   4982160
+2016   4527856
+2240   4325312
+2464   4051760
+2688   3767640
+2912   3612520
+3136   3415208
+3360   3258656
+3584   3113360
diff --git a/logs/addsub.png b/logs/addsub.png
index 1113ed3..56391d9 100644
Binary files a/logs/addsub.png and b/logs/addsub.png differ
diff --git a/logs/expt.log b/logs/expt.log
index fb0b718..d0a6f34 100644
--- a/logs/expt.log
+++ b/logs/expt.log
@@ -1,7 +1,7 @@
-14364       666
-21532       253
-28700       117
-57372        17
-71708         9
-86044         5
-114716         2
+513       680
+769       257
+1025       117
+2049        17
+2561         9
+3073         5
+4097         2
diff --git a/logs/expt.png b/logs/expt.png
index b534a9b..137cd03 100644
Binary files a/logs/expt.png and b/logs/expt.png differ
diff --git a/logs/expt_2k.log b/logs/expt_2k.log
new file mode 100644
index 0000000..dda04b2
--- /dev/null
+++ b/logs/expt_2k.log
@@ -0,0 +1,6 @@
+521       736
+607       552
+1279       112
+2203        33
+3217        13
+4253         6
diff --git a/logs/expt_dr.log b/logs/expt_dr.log
index f80a9ee..d578a42 100644
--- a/logs/expt_dr.log
+++ b/logs/expt_dr.log
@@ -1,7 +1,7 @@
-14896      1088
-21952       468
-29008       244
-43120        91
-58016        43
-86240        15
-115248         6
+532      1064
+784       460
+1036       240
+1540        91
+2072        43
+3080        15
+4116         6
diff --git a/logs/graphs.dem b/logs/graphs.dem
index 4441c0d..0553b79 100644
--- a/logs/graphs.dem
+++ b/logs/graphs.dem
@@ -1,5 +1,5 @@
 set terminal png color
-set size 1.5
+set size 1.75
 set ylabel "Operations per Second"
 set xlabel "Operand size (bits)"
 
@@ -10,7 +10,7 @@ set output "mult.png"
 plot 'sqr.log' smooth bezier title "Squaring (without Karatsuba)", 'sqr_kara.log' smooth bezier title "Squaring (Karatsuba)", 'mult.log' smooth bezier title "Multiplication (without Karatsuba)", 'mult_kara.log' smooth bezier title "Multiplication (Karatsuba)"
 
 set output "expt.png"
-plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)"
+plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)", 'expt_2k.log' smooth bezier title "Exptmod (2k Reduction)"
 
 set output "invmod.png"
 plot 'invmod.log' smooth bezier title "Modular Inverse"
diff --git a/logs/invmod.log b/logs/invmod.log
index e84ba9f..d1198fb 100644
--- a/logs/invmod.log
+++ b/logs/invmod.log
@@ -1,32 +1,32 @@
-112     15608
-224      7840
-336      5104
-448      3376
-560      2616
-672      1984
-784      1640
-896      2056
-1008      1136
-1120       936
-1232      1240
-1344      1112
-1456       608
-1568       873
-1680       492
-1792       444
-1904       640
-2016       584
-2128       328
-2240       307
-2352       283
-2464       256
-2576       393
-2688       365
-2800       344
-2912       196
-3024       301
-3136       170
-3248       160
-3360       250
-3472       144
-3584       224
+112     16248
+224      8192
+336      5320
+448      3560
+560      2728
+672      2064
+784      1704
+896      2176
+1008      1184
+1120       976
+1232      1280
+1344      1176
+1456       624
+1568       912
+1680       504
+1792       452
+1904       658
+2016       608
+2128       336
+2240       312
+2352       288
+2464       264
+2576       408
+2688       376
+2800       354
+2912       198
+3024       307
+3136       173
+3248       162
+3360       256
+3472       145
+3584       226
diff --git a/logs/invmod.png b/logs/invmod.png
index a38bfd5..a497a72 100644
Binary files a/logs/invmod.png and b/logs/invmod.png differ
diff --git a/logs/k7/README b/logs/k7/README
new file mode 100644
index 0000000..ea20c81
--- /dev/null
+++ b/logs/k7/README
@@ -0,0 +1,13 @@
+To use the pretty graphs you have to first build/run the ltmtest from the root directory of the package.  
+Todo this type 
+
+make timing ; ltmtest
+
+in the root.  It will run for a while [about ten minutes on most PCs] and produce a series of .log files in logs/.
+
+After doing that run "gnuplot graphs.dem" to make the PNGs.  If you managed todo that all so far just open index.html to view
+them all :-)
+
+Have fun
+
+Tom
\ No newline at end of file
diff --git a/logs/k7/add.log b/logs/k7/add.log
new file mode 100644
index 0000000..796ab48
--- /dev/null
+++ b/logs/k7/add.log
@@ -0,0 +1,16 @@
+224  11069160
+448   9156136
+672   8089755
+896   7399424
+1120   6389352
+1344   5818648
+1568   5257112
+1792   4982160
+2016   4527856
+2240   4325312
+2464   4051760
+2688   3767640
+2912   3612520
+3136   3415208
+3360   3258656
+3584   3113360
diff --git a/logs/k7/addsub.png b/logs/k7/addsub.png
new file mode 100644
index 0000000..56391d9
Binary files /dev/null and b/logs/k7/addsub.png differ
diff --git a/logs/k7/expt.log b/logs/k7/expt.log
new file mode 100644
index 0000000..46bb50b
--- /dev/null
+++ b/logs/k7/expt.log
@@ -0,0 +1,7 @@
+513       664
+769       256
+1025       117
+2049        17
+2561         9
+3073         5
+4097         2
diff --git a/logs/k7/expt.png b/logs/k7/expt.png
new file mode 100644
index 0000000..fc82677
Binary files /dev/null and b/logs/k7/expt.png differ
diff --git a/logs/k7/expt_dr.log b/logs/k7/expt_dr.log
new file mode 100644
index 0000000..7df658f
--- /dev/null
+++ b/logs/k7/expt_dr.log
@@ -0,0 +1,7 @@
+532      1088
+784       460
+1036       240
+1540        92
+2072        43
+3080        15
+4116         6
diff --git a/logs/k7/graphs.dem b/logs/k7/graphs.dem
new file mode 100644
index 0000000..c580495
--- /dev/null
+++ b/logs/k7/graphs.dem
@@ -0,0 +1,17 @@
+set terminal png color
+set size 1.75
+set ylabel "Operations per Second"
+set xlabel "Operand size (bits)"
+
+set output "addsub.png"
+plot 'add.log' smooth bezier title "Addition", 'sub.log' smooth bezier title "Subtraction"
+
+set output "mult.png"
+plot 'sqr.log' smooth bezier title "Squaring (without Karatsuba)", 'sqr_kara.log' smooth bezier title "Squaring (Karatsuba)", 'mult.log' smooth bezier title "Multiplication (without Karatsuba)", 'mult_kara.log' smooth bezier title "Multiplication (Karatsuba)"
+
+set output "expt.png"
+plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)"
+
+set output "invmod.png"
+plot 'invmod.log' smooth bezier title "Modular Inverse"
+
diff --git a/logs/k7/index.html b/logs/k7/index.html
new file mode 100644
index 0000000..f3a5562
--- /dev/null
+++ b/logs/k7/index.html
@@ -0,0 +1,24 @@
+<html>
+<head>
+<title>LibTomMath Log Plots</title>
+</head>
+<body>
+
+<h1>Addition and Subtraction</h1>
+<center><img src=addsub.png></center>
+<hr>
+
+<h1>Multipliers</h1>
+<center><img src=mult.png></center>
+<hr>
+
+<h1>Exptmod</h1>
+<center><img src=expt.png></center>
+<hr>
+
+<h1>Modular Inverse</h1>
+<center><img src=invmod.png></center>
+<hr>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/logs/k7/invmod.log b/logs/k7/invmod.log
new file mode 100644
index 0000000..d1198fb
--- /dev/null
+++ b/logs/k7/invmod.log
@@ -0,0 +1,32 @@
+112     16248
+224      8192
+336      5320
+448      3560
+560      2728
+672      2064
+784      1704
+896      2176
+1008      1184
+1120       976
+1232      1280
+1344      1176
+1456       624
+1568       912
+1680       504
+1792       452
+1904       658
+2016       608
+2128       336
+2240       312
+2352       288
+2464       264
+2576       408
+2688       376
+2800       354
+2912       198
+3024       307
+3136       173
+3248       162
+3360       256
+3472       145
+3584       226
diff --git a/logs/k7/invmod.png b/logs/k7/invmod.png
new file mode 100644
index 0000000..a497a72
Binary files /dev/null and b/logs/k7/invmod.png differ
diff --git a/logs/k7/mult.log b/logs/k7/mult.log
new file mode 100644
index 0000000..4b1bff3
--- /dev/null
+++ b/logs/k7/mult.log
@@ -0,0 +1,17 @@
+896    322904
+1344    151592
+1792     90472
+2240     59984
+2688     42624
+3136     31872
+3584     24704
+4032     19704
+4480     16096
+4928     13376
+5376     11272
+5824      9616
+6272      8360
+6720      7304
+7168      1664
+7616      1472
+8064      1328
diff --git a/logs/k7/mult.png b/logs/k7/mult.png
new file mode 100644
index 0000000..3cd8a93
Binary files /dev/null and b/logs/k7/mult.png differ
diff --git a/logs/k7/mult_kara.log b/logs/k7/mult_kara.log
new file mode 100644
index 0000000..53c0864
--- /dev/null
+++ b/logs/k7/mult_kara.log
@@ -0,0 +1,17 @@
+896    322872
+1344    151688
+1792     90480
+2240     59984
+2688     42656
+3136     32144
+3584     25840
+4032     21328
+4480     17856
+4928     14928
+5376     12856
+5824     11256
+6272      9880
+6720      8984
+7168      7928
+7616      7200
+8064      6576
diff --git a/logs/k7/sqr.log b/logs/k7/sqr.log
new file mode 100644
index 0000000..2fb2e98
--- /dev/null
+++ b/logs/k7/sqr.log
@@ -0,0 +1,17 @@
+896    415472
+1344    223736
+1792    141232
+2240     97624
+2688     71400
+3136     54800
+3584     16904
+4032     13528
+4480     10968
+4928      9128
+5376      7784
+5824      6672
+6272      5760
+6720      5056
+7168      4440
+7616      3952
+8064      3512
diff --git a/logs/k7/sqr_kara.log b/logs/k7/sqr_kara.log
new file mode 100644
index 0000000..ba30f9e
--- /dev/null
+++ b/logs/k7/sqr_kara.log
@@ -0,0 +1,17 @@
+896    420464
+1344    224800
+1792    142808
+2240     97704
+2688     71416
+3136     54504
+3584     38320
+4032     32360
+4480     27576
+4928     23840
+5376     20688
+5824     18264
+6272     16176
+6720     14440
+7168     11688
+7616     10752
+8064      9936
diff --git a/logs/k7/sub.log b/logs/k7/sub.log
new file mode 100644
index 0000000..91c7d65
--- /dev/null
+++ b/logs/k7/sub.log
@@ -0,0 +1,16 @@
+224   9728504
+448   8573648
+672   7488096
+896   6714064
+1120   5950472
+1344   5457400
+1568   5038896
+1792   4683632
+2016   4384656
+2240   4105976
+2464   3871608
+2688   3650680
+2912   3463552
+3136   3290016
+3360   3135272
+3584   2993848
diff --git a/logs/mult.log b/logs/mult.log
index 835dc52..4b1bff3 100644
--- a/logs/mult.log
+++ b/logs/mult.log
@@ -1,17 +1,17 @@
-896    321504
-1344    150784
-1792     90288
-2240     59760
-2688     42480
-3136     32056
-3584     24600
-4032     19656
-4480     16024
-4928     13328
-5376     11280
-5824      9624
-6272      8336
-6720      7280
-7168      1648
-7616      1464
-8064      1296
+896    322904
+1344    151592
+1792     90472
+2240     59984
+2688     42624
+3136     31872
+3584     24704
+4032     19704
+4480     16096
+4928     13376
+5376     11272
+5824      9616
+6272      8360
+6720      7304
+7168      1664
+7616      1472
+8064      1328
diff --git a/logs/mult.png b/logs/mult.png
index c49a434..3cd8a93 100644
Binary files a/logs/mult.png and b/logs/mult.png differ
diff --git a/logs/mult_kara.log b/logs/mult_kara.log
index 0babf2e..53c0864 100644
--- a/logs/mult_kara.log
+++ b/logs/mult_kara.log
@@ -1,17 +1,17 @@
-896    321928
-1344    150752
-1792     90136
-2240     59888
-2688     42480
-3136     32080
-3584     25744
-4032     21216
-4480     17912
-4928     14896
-5376     12936
-5824     11216
-6272      9848
-6720      8896
-7168      7968
-7616      7248
-8064      6600
+896    322872
+1344    151688
+1792     90480
+2240     59984
+2688     42656
+3136     32144
+3584     25840
+4032     21328
+4480     17856
+4928     14928
+5376     12856
+5824     11256
+6272      9880
+6720      8984
+7168      7928
+7616      7200
+8064      6576
diff --git a/logs/p4/README b/logs/p4/README
new file mode 100644
index 0000000..ea20c81
--- /dev/null
+++ b/logs/p4/README
@@ -0,0 +1,13 @@
+To use the pretty graphs you have to first build/run the ltmtest from the root directory of the package.  
+Todo this type 
+
+make timing ; ltmtest
+
+in the root.  It will run for a while [about ten minutes on most PCs] and produce a series of .log files in logs/.
+
+After doing that run "gnuplot graphs.dem" to make the PNGs.  If you managed todo that all so far just open index.html to view
+them all :-)
+
+Have fun
+
+Tom
\ No newline at end of file
diff --git a/logs/p4/add.log b/logs/p4/add.log
new file mode 100644
index 0000000..72b2506
--- /dev/null
+++ b/logs/p4/add.log
@@ -0,0 +1,16 @@
+224   8113248
+448   6585584
+672   5687678
+896   4761144
+1120   4111592
+1344   3995154
+1568   3532387
+1792   3225400
+2016   2963960
+2240   2720112
+2464   2533952
+2688   2307168
+2912   2287064
+3136   2150160
+3360   2035992
+3584   1936304
diff --git a/logs/p4/addsub.png b/logs/p4/addsub.png
new file mode 100644
index 0000000..f4398ca
Binary files /dev/null and b/logs/p4/addsub.png differ
diff --git a/logs/p4/expt.log b/logs/p4/expt.log
new file mode 100644
index 0000000..3e6ffb8
--- /dev/null
+++ b/logs/p4/expt.log
@@ -0,0 +1,7 @@
+513       195
+769        68
+1025        31
+2049         4
+2561         2
+3073         1
+4097         0
diff --git a/logs/p4/expt.png b/logs/p4/expt.png
new file mode 100644
index 0000000..dac1ce2
Binary files /dev/null and b/logs/p4/expt.png differ
diff --git a/logs/p4/expt_dr.log b/logs/p4/expt_dr.log
new file mode 100644
index 0000000..2f5f6a3
--- /dev/null
+++ b/logs/p4/expt_dr.log
@@ -0,0 +1,7 @@
+532       393
+784       158
+1036        79
+1540        27
+2072        12
+3080         4
+4116         1
diff --git a/logs/p4/graphs.dem b/logs/p4/graphs.dem
new file mode 100644
index 0000000..c580495
--- /dev/null
+++ b/logs/p4/graphs.dem
@@ -0,0 +1,17 @@
+set terminal png color
+set size 1.75
+set ylabel "Operations per Second"
+set xlabel "Operand size (bits)"
+
+set output "addsub.png"
+plot 'add.log' smooth bezier title "Addition", 'sub.log' smooth bezier title "Subtraction"
+
+set output "mult.png"
+plot 'sqr.log' smooth bezier title "Squaring (without Karatsuba)", 'sqr_kara.log' smooth bezier title "Squaring (Karatsuba)", 'mult.log' smooth bezier title "Multiplication (without Karatsuba)", 'mult_kara.log' smooth bezier title "Multiplication (Karatsuba)"
+
+set output "expt.png"
+plot 'expt.log' smooth bezier title "Exptmod (Montgomery)", 'expt_dr.log' smooth bezier title "Exptmod (Dimminished Radix)"
+
+set output "invmod.png"
+plot 'invmod.log' smooth bezier title "Modular Inverse"
+
diff --git a/logs/p4/index.html b/logs/p4/index.html
new file mode 100644
index 0000000..f3a5562
--- /dev/null
+++ b/logs/p4/index.html
@@ -0,0 +1,24 @@
+<html>
+<head>
+<title>LibTomMath Log Plots</title>
+</head>
+<body>
+
+<h1>Addition and Subtraction</h1>
+<center><img src=addsub.png></center>
+<hr>
+
+<h1>Multipliers</h1>
+<center><img src=mult.png></center>
+<hr>
+
+<h1>Exptmod</h1>
+<center><img src=expt.png></center>
+<hr>
+
+<h1>Modular Inverse</h1>
+<center><img src=invmod.png></center>
+<hr>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/logs/p4/invmod.log b/logs/p4/invmod.log
new file mode 100644
index 0000000..096087b
--- /dev/null
+++ b/logs/p4/invmod.log
@@ -0,0 +1,32 @@
+112     13608
+224      6872
+336      4264
+448      2792
+560      2144
+672      1560
+784      1296
+896      1672
+1008       896
+1120       736
+1232      1024
+1344       888
+1456       472
+1568       680
+1680       373
+1792       328
+1904       484
+2016       436
+2128       232
+2240       211
+2352       200
+2464       177
+2576       293
+2688       262
+2800       251
+2912       137
+3024       216
+3136       117
+3248       113
+3360       181
+3472        98
+3584       158
diff --git a/logs/p4/invmod.png b/logs/p4/invmod.png
new file mode 100644
index 0000000..3b0580f
Binary files /dev/null and b/logs/p4/invmod.png differ
diff --git a/logs/p4/mult.log b/logs/p4/mult.log
new file mode 100644
index 0000000..6e43806
--- /dev/null
+++ b/logs/p4/mult.log
@@ -0,0 +1,17 @@
+896     77600
+1344     35776
+1792     19688
+2240     13248
+2688      9424
+3136      7056
+3584      5464
+4032      4368
+4480      3568
+4928      2976
+5376      2520
+5824      2152
+6272      1872
+6720      1632
+7168       650
+7616       576
+8064       515
diff --git a/logs/p4/mult.png b/logs/p4/mult.png
new file mode 100644
index 0000000..8623558
Binary files /dev/null and b/logs/p4/mult.png differ
diff --git a/logs/p4/mult_kara.log b/logs/p4/mult_kara.log
new file mode 100644
index 0000000..e1d50a6
--- /dev/null
+++ b/logs/p4/mult_kara.log
@@ -0,0 +1,17 @@
+896     77752
+1344     35832
+1792     19688
+2240     14704
+2688     10832
+3136      8336
+3584      6600
+4032      5424
+4480      4648
+4928      3976
+5376      3448
+5824      3016
+6272      2664
+6720      2384
+7168      2120
+7616      1912
+8064      1752
diff --git a/logs/p4/sqr.log b/logs/p4/sqr.log
new file mode 100644
index 0000000..b133fb3
--- /dev/null
+++ b/logs/p4/sqr.log
@@ -0,0 +1,17 @@
+896    128088
+1344     63640
+1792     37968
+2240     25488
+2688     18176
+3136     13672
+3584      4920
+4032      3912
+4480      3160
+4928      2616
+5376      2216
+5824      1896
+6272      1624
+6720      1408
+7168      1240
+7616      1096
+8064       984
diff --git a/logs/p4/sqr_kara.log b/logs/p4/sqr_kara.log
new file mode 100644
index 0000000..13e4f3e
--- /dev/null
+++ b/logs/p4/sqr_kara.log
@@ -0,0 +1,17 @@
+896    127456
+1344     63752
+1792     37920
+2240     25440
+2688     18200
+3136     13728
+3584     10968
+4032      9072
+4480      7608
+4928      6440
+5376      5528
+5824      4768
+6272      4328
+6720      3888
+7168      3504
+7616      3176
+8064      2896
diff --git a/logs/p4/sub.log b/logs/p4/sub.log
new file mode 100644
index 0000000..424de32
--- /dev/null
+++ b/logs/p4/sub.log
@@ -0,0 +1,16 @@
+224   7355896
+448   6162880
+672   5218984
+896   4622776
+1120   3999320
+1344   3629480
+1568   3290384
+1792   2954752
+2016   2737056
+2240   2563320
+2464   2451928
+2688   2310920
+2912   2139048
+3136   2034080
+3360   1890800
+3584   1808624
diff --git a/logs/sqr.log b/logs/sqr.log
index 2ed78eb..2fb2e98 100644
--- a/logs/sqr.log
+++ b/logs/sqr.log
@@ -1,17 +1,17 @@
-896    416968
-1344    223672
-1792    141552
-2240     97280
-2688     71304
-3136     54648
-3584     16264
-4032     13000
-4480     10528
-4928      8776
-5376      7464
-5824      6440
-6272      5520
-6720      4808
-7168      4264
-7616      3784
-8064      3368
+896    415472
+1344    223736
+1792    141232
+2240     97624
+2688     71400
+3136     54800
+3584     16904
+4032     13528
+4480     10968
+4928      9128
+5376      7784
+5824      6672
+6272      5760
+6720      5056
+7168      4440
+7616      3952
+8064      3512
diff --git a/logs/sqr_kara.log b/logs/sqr_kara.log
index b890211..ba30f9e 100644
--- a/logs/sqr_kara.log
+++ b/logs/sqr_kara.log
@@ -1,17 +1,17 @@
-896    416656
-1344    223728
-1792    141288
-2240     97456
-2688     71152
-3136     54392
-3584     38552
-4032     32216
-4480     27384
-4928     23792
-5376     20728
-5824     18232
-6272     16160
-6720     14408
-7168     11696
-7616     10768
-8064      9920
+896    420464
+1344    224800
+1792    142808
+2240     97704
+2688     71416
+3136     54504
+3584     38320
+4032     32360
+4480     27576
+4928     23840
+5376     20688
+5824     18264
+6272     16176
+6720     14440
+7168     11688
+7616     10752
+8064      9936
diff --git a/logs/sub.log b/logs/sub.log
index 14c519d..91c7d65 100644
--- a/logs/sub.log
+++ b/logs/sub.log
@@ -1,16 +1,16 @@
-224   9862520
-448   8562344
-672   7661400
-896   6838128
-1120   5911144
-1344   5394040
-1568   4993760
-1792   4624240
-2016   4332024
-2240   4029312
-2464   3790784
-2688   3587216
-2912   3397952
-3136   3239736
-3360   3080616
-3584   2933104
+224   9728504
+448   8573648
+672   7488096
+896   6714064
+1120   5950472
+1344   5457400
+1568   5038896
+1792   4683632
+2016   4384656
+2240   4105976
+2464   3871608
+2688   3650680
+2912   3463552
+3136   3290016
+3360   3135272
+3584   2993848
diff --git a/makefile b/makefile
index 4f5a627..d64ad23 100644
--- a/makefile
+++ b/makefile
@@ -1,6 +1,6 @@
 CFLAGS  +=  -I./ -Wall -W -Wshadow -O3 -fomit-frame-pointer -funroll-loops
 
-VERSION=0.17
+VERSION=0.18
 
 default: libtommath.a
 
@@ -33,7 +33,9 @@ bn_mp_to_signed_bin.o bn_mp_unsigned_bin_size.o bn_mp_signed_bin_size.o bn_radix
 bn_mp_xor.o bn_mp_and.o bn_mp_or.o bn_mp_rand.o bn_mp_montgomery_calc_normalization.o \
 bn_mp_prime_is_divisible.o bn_prime_tab.o bn_mp_prime_fermat.o bn_mp_prime_miller_rabin.o \
 bn_mp_prime_is_prime.o bn_mp_prime_next_prime.o bn_mp_dr_reduce.o bn_mp_multi.o \
-bn_mp_dr_is_modulus.o bn_mp_dr_setup.o
+bn_mp_dr_is_modulus.o bn_mp_dr_setup.o bn_mp_reduce_setup.o \
+bn_mp_toom_mul.o bn_mp_toom_sqr.o bn_mp_div_3.o bn_s_mp_exptmod.o \
+bn_mp_reduce_2k.o bn_mp_reduce_is_2k.o bn_mp_reduce_2k_setup.o
 
 libtommath.a:  $(OBJECTS)
 	$(AR) $(ARFLAGS) libtommath.a $(OBJECTS)
@@ -63,6 +65,11 @@ docdvi: tommath.src
 	makeindex tommath
 	latex tommath > /dev/null
 		
+# poster, makes the single page PDF poster
+poster: poster.tex
+	pdflatex poster
+	rm -f poster.aux poster.log 
+	
 # makes the LTM book PS/PDF file, requires tetex, cleans up the LaTeX temp files
 docs:	
 	cd pics ; make pdfes
@@ -88,11 +95,12 @@ manual:
 	
 clean:
 	rm -f *.pdf *.o *.a *.obj *.lib *.exe etclib/*.o demo/demo.o test ltmtest mpitest mtest/mtest mtest/mtest.exe \
-        tommath.idx tommath.toc tommath.log tommath.aux tommath.dvi tommath.lof tommath.ind tommath.ilg *.ps *.pdf *.log *.s mpi.c 
+        tommath.idx tommath.toc tommath.log tommath.aux tommath.dvi tommath.lof tommath.ind tommath.ilg *.ps *.pdf *.log *.s mpi.c \
+        poster.aux poster.dvi poster.log
 	cd etc ; make clean
 	cd pics ; make clean
 
-zipup: clean manual
+zipup: clean manual poster
 	perl gen.pl ; mv mpi.c pre_gen/ ; \
 	cd .. ; rm -rf ltm* libtommath-$(VERSION) ; mkdir libtommath-$(VERSION) ; \
 	cp -R ./libtommath/* ./libtommath-$(VERSION)/ ; tar -c libtommath-$(VERSION)/* > ltm-$(VERSION).tar ; \
diff --git a/makefile.bcc b/makefile.bcc
new file mode 100644
index 0000000..b4603f2
--- /dev/null
+++ b/makefile.bcc
@@ -0,0 +1,37 @@
+#
+# Borland C++Builder Makefile (makefile.bcc)
+#
+
+
+LIB = tlib
+CC = bcc32
+CFLAGS = -c -O2 -I.
+
+OBJECTS=bncore.obj bn_mp_init.obj bn_mp_clear.obj bn_mp_exch.obj bn_mp_grow.obj bn_mp_shrink.obj \
+bn_mp_clamp.obj bn_mp_zero.obj  bn_mp_set.obj bn_mp_set_int.obj bn_mp_init_size.obj bn_mp_copy.obj \
+bn_mp_init_copy.obj bn_mp_abs.obj bn_mp_neg.obj bn_mp_cmp_mag.obj bn_mp_cmp.obj bn_mp_cmp_d.obj \
+bn_mp_rshd.obj bn_mp_lshd.obj bn_mp_mod_2d.obj bn_mp_div_2d.obj bn_mp_mul_2d.obj bn_mp_div_2.obj \
+bn_mp_mul_2.obj bn_s_mp_add.obj bn_s_mp_sub.obj bn_fast_s_mp_mul_digs.obj bn_s_mp_mul_digs.obj \
+bn_fast_s_mp_mul_high_digs.obj bn_s_mp_mul_high_digs.obj bn_fast_s_mp_sqr.obj bn_s_mp_sqr.obj \
+bn_mp_add.obj bn_mp_sub.obj bn_mp_karatsuba_mul.obj bn_mp_mul.obj bn_mp_karatsuba_sqr.obj \
+bn_mp_sqr.obj bn_mp_div.obj bn_mp_mod.obj bn_mp_add_d.obj bn_mp_sub_d.obj bn_mp_mul_d.obj \
+bn_mp_div_d.obj bn_mp_mod_d.obj bn_mp_expt_d.obj bn_mp_addmod.obj bn_mp_submod.obj \
+bn_mp_mulmod.obj bn_mp_sqrmod.obj bn_mp_gcd.obj bn_mp_lcm.obj bn_fast_mp_invmod.obj bn_mp_invmod.obj \
+bn_mp_reduce.obj bn_mp_montgomery_setup.obj bn_fast_mp_montgomery_reduce.obj bn_mp_montgomery_reduce.obj \
+bn_mp_exptmod_fast.obj bn_mp_exptmod.obj bn_mp_2expt.obj bn_mp_n_root.obj bn_mp_jacobi.obj bn_reverse.obj \
+bn_mp_count_bits.obj bn_mp_read_unsigned_bin.obj bn_mp_read_signed_bin.obj bn_mp_to_unsigned_bin.obj \
+bn_mp_to_signed_bin.obj bn_mp_unsigned_bin_size.obj bn_mp_signed_bin_size.obj bn_radix.obj \
+bn_mp_xor.obj bn_mp_and.obj bn_mp_or.obj bn_mp_rand.obj bn_mp_montgomery_calc_normalization.obj \
+bn_mp_prime_is_divisible.obj bn_prime_tab.obj bn_mp_prime_fermat.obj bn_mp_prime_miller_rabin.obj \
+bn_mp_prime_is_prime.obj bn_mp_prime_next_prime.obj bn_mp_dr_reduce.obj bn_mp_multi.obj \
+bn_mp_dr_is_modulus.obj bn_mp_dr_setup.obj bn_mp_reduce_setup.obj \
+bn_mp_toom_mul.obj bn_mp_toom_sqr.obj bn_mp_div_3.obj bn_s_mp_exptmod.obj \
+bn_mp_reduce_2k.obj bn_mp_reduce_is_2k.obj bn_mp_reduce_2k_setup.obj
+
+TARGET = libtommath.lib
+
+$(TARGET): $(OBJECTS)
+
+.c.objbj:
+	$(CC) $(CFLAGS) $<
+	$(LIB) $(TARGET) -+$@
\ No newline at end of file
diff --git a/makefile.msvc b/makefile.msvc
index dcc14b1..db2b4bc 100644
--- a/makefile.msvc
+++ b/makefile.msvc
@@ -23,7 +23,10 @@ bn_mp_to_signed_bin.obj bn_mp_unsigned_bin_size.obj bn_mp_signed_bin_size.obj bn
 bn_mp_xor.obj bn_mp_and.obj bn_mp_or.obj bn_mp_rand.obj bn_mp_montgomery_calc_normalization.obj \
 bn_mp_prime_is_divisible.obj bn_prime_tab.obj bn_mp_prime_fermat.obj bn_mp_prime_miller_rabin.obj \
 bn_mp_prime_is_prime.obj bn_mp_prime_next_prime.obj bn_mp_dr_reduce.obj bn_mp_multi.obj \
-bn_mp_dr_is_modulus.obj bn_mp_dr_setup.obj
+bn_mp_dr_is_modulus.obj bn_mp_dr_setup.obj bn_mp_reduce_setup.obj \
+bn_mp_toom_mul.obj bn_mp_toom_sqr.obj bn_mp_div_3.obj bn_s_mp_exptmod.obj \
+bn_mp_reduce_2k.obj bn_mp_reduce_is_2k.obj bn_mp_reduce_2k_setup.obj
+
 
 
 library: $(OBJECTS)
diff --git a/mtest/mtest.c b/mtest/mtest.c
index 086e7bc..5abc1a4 100644
--- a/mtest/mtest.c
+++ b/mtest/mtest.c
@@ -40,14 +40,10 @@ void rand_num(mp_int *a)
    int n, size;
    unsigned char buf[2048];
 
-top:
-   size = 1 + ((fgetc(rng)*fgetc(rng)) % 1024);
+   size = 1 + ((fgetc(rng)<<8) + fgetc(rng)) % 1031;
    buf[0] = (fgetc(rng)&1)?1:0;
    fread(buf+1, 1, size, rng);
-   for (n = 0; n < size; n++) {
-       if (buf[n+1]) break;
-   }
-   if (n == size) goto top;
+   while (buf[1] == 0) buf[1] = fgetc(rng);
    mp_read_raw(a, buf, 1+size);
 }
 
@@ -56,14 +52,10 @@ void rand_num2(mp_int *a)
    int n, size;
    unsigned char buf[2048];
 
-top:
-   size = 1 + ((fgetc(rng)*fgetc(rng)) % 96);
+   size = 1 + ((fgetc(rng)<<8) + fgetc(rng)) % 97;
    buf[0] = (fgetc(rng)&1)?1:0;
    fread(buf+1, 1, size, rng);
-   for (n = 0; n < size; n++) {
-       if (buf[n+1]) break;
-   }
-   if (n == size) goto top;
+   while (buf[1] == 0) buf[1] = fgetc(rng);
    mp_read_raw(a, buf, 1+size);
 }
 
@@ -73,6 +65,7 @@ int main(void)
 {
    int n;
    mp_int a, b, c, d, e;
+   clock_t t1;
    char buf[4096];
 
    mp_init(&a);
@@ -108,8 +101,14 @@ int main(void)
       }
    }
 
+   t1 = clock();
    for (;;) {
-       n =  fgetc(rng) % 13;
+      if (clock() - t1 > CLOCKS_PER_SEC) {
+         sleep(1);
+         t1 = clock();
+      }
+   
+       n = fgetc(rng) % 13;
 
    if (n == 0) {
        /* add tests */
@@ -227,6 +226,7 @@ int main(void)
       rand_num2(&a);
       rand_num2(&b);
       rand_num2(&c);
+//      if (c.dp[0]&1) mp_add_d(&c, 1, &c);
       a.sign = b.sign = c.sign = 0;
       mp_exptmod(&a, &b, &c, &d);
       printf("expt\n");
diff --git a/pics/expt_state.sxd b/pics/expt_state.sxd
new file mode 100644
index 0000000..6518404
Binary files /dev/null and b/pics/expt_state.sxd differ
diff --git a/pics/expt_state.tif b/pics/expt_state.tif
new file mode 100644
index 0000000..cb06e8e
Binary files /dev/null and b/pics/expt_state.tif differ
diff --git a/pics/makefile b/pics/makefile
index 4be4899..302adec 100644
--- a/pics/makefile
+++ b/pics/makefile
@@ -5,12 +5,18 @@ default:  pses
 
 sliding_window.ps: sliding_window.tif
 	tiff2ps -c -e sliding_window.tif > sliding_window.ps
+	
+expt_state.ps: expt_state.tif
+	tiff2ps -c -e expt_state.tif > expt_state.ps
 
 sliding_window.pdf: sliding_window.ps
 	epstopdf sliding_window.ps
+	
+expt_state.pdf: expt_state.ps
+	epstopdf expt_state.ps
 
-pses: sliding_window.ps 
-pdfes: sliding_window.pdf
+pses: sliding_window.ps expt_state.ps
+pdfes: sliding_window.pdf expt_state.pdf
 
 clean:
 	rm -rf *.ps *.pdf .xvpics
diff --git a/poster.pdf b/poster.pdf
new file mode 100644
index 0000000..f2b01ba
Binary files /dev/null and b/poster.pdf differ
diff --git a/poster.tex b/poster.tex
new file mode 100644
index 0000000..9bf5824
--- /dev/null
+++ b/poster.tex
@@ -0,0 +1,32 @@
+\documentclass[landscape,11pt]{article}
+\usepackage{amsmath, amssymb}
+\begin{document}
+
+\hspace*{-3in}
+\begin{tabular}{llllll}
+$c = a + b$  & {\tt mp\_add(\&a, \&b, \&c)} & $b = 2a$  & {\tt mp\_mul\_2(\&a, \&b)} & Greater Than & MP\_GT \\
+$c = a - b$  & {\tt mp\_sub(\&a, \&b, \&c)} & $b = a/2$ & {\tt mp\_div\_2(\&a, \&b)} & Equal To & MP\_EQ \\
+$c = ab $   & {\tt mp\_mul(\&a, \&b, \&c)}  & $c = 2^ba$  & {\tt mp\_mul\_2d(\&a, b, \&c)} & Less Than & MP\_LT \\
+$b = a^2 $  & {\tt mp\_sqr(\&a, \&b)}       & $c = a/2^b, d = a \mod 2^b$ & {\tt mp\_div\_2d(\&a, b, \&c, \&d)} \\
+$c = \lfloor a/b \rfloor, d = a \mod b$ & {\tt mp\_div(\&a, \&b, \&c, \&d)} & $c = a \mod 2^b $  & {\tt mp\_mod\_2d(\&a, b, \&c)}  & Bits per digit & DIGIT\_BIT \\
+ && \\
+$a = b $  & {\tt mp\_set\_int(\&a, b)}  & $c = a \vee b$  & {\tt mp\_or(\&a, \&b, \&c)}  \\
+$b = a $  & {\tt mp\_copy(\&a, \&b)} & $c = a \wedge b$  & {\tt mp\_and(\&a, \&b, \&c)}  \\
+ && $c = a \oplus b$  & {\tt mp\_xor(\&a, \&b, \&c)}  \\
+ & \\
+$b = -a $  & {\tt mp\_neg(\&a, \&b)}  & $d = a + b \mod c$  & {\tt mp\_addmod(\&a, \&b, \&c, \&d)}  \\
+$b = |a| $  & {\tt mp\_abs(\&a, \&b)} & $d = a - b \mod c$  & {\tt mp\_submod(\&a, \&b, \&c, \&d)}  \\
+ && $d = ab \mod c$  & {\tt mp\_mulmod(\&a, \&b, \&c, \&d)}  \\
+Compare $a$ and $b$ & {\tt mp\_cmp(\&a, \&b)} & $c = a^2 \mod b$  & {\tt mp\_sqrmod(\&a, \&b, \&c)}  \\
+Is Zero? & {\tt mp\_iszero(\&a)} & $c = a^{-1} \mod b$  & {\tt mp\_invmod(\&a, \&b, \&c)} \\
+Is Even? & {\tt mp\_iseven(\&a)} & $d = a^b \mod c$ & {\tt mp\_exptmod(\&a, \&b, \&c, \&d)} \\
+Is Odd ? & {\tt mp\_isodd(\&a)} \\
+&\\
+$\vert \vert a \vert \vert$ & {\tt mp\_unsigned\_bin\_size(\&a)} & $res$ = 1 if $a$ prime to $t$ rounds? & {\tt mp\_prime\_is\_prime(\&a, t, \&res)} \\
+$buf \leftarrow a$          & {\tt mp\_to\_unsigned\_bin(\&a, buf)} & Next prime after $a$ to $t$ rounds. & {\tt mp\_prime\_next\_prime(\&a, t)} \\
+$a \leftarrow buf[0..len-1]$          & {\tt mp\_read\_unsigned\_bin(\&a, buf, len)} \\
+&\\
+$b = \sqrt{a}$ & {\tt mp\_sqrt(\&a, \&b)}  & $c = \mbox{gcd}(a, b)$ & {\tt mp\_gcd(\&a, \&b, \&c)} \\
+$c = a^{1/b}$ & {\tt mp\_n\_root(\&a, b, \&c)} & $c = \mbox{lcm}(a, b)$ & {\tt mp\_lcm(\&a, \&b, \&c)} \\
+\end{tabular}
+\end{document}
\ No newline at end of file
diff --git a/pre_gen/mpi.c b/pre_gen/mpi.c
index bd6f2ce..efffd31 100644
--- a/pre_gen/mpi.c
+++ b/pre_gen/mpi.c
@@ -168,7 +168,7 @@ __ERR:mp_clear_multi (&x, &y, &u, &v, &B, &D, NULL);
  */
 #include <tommath.h>
 
-/* computes xR^-1 == x (mod N) via Montgomery Reduction 
+/* computes xR**-1 == x (mod N) via Montgomery Reduction 
  * 
  * This is an optimized implementation of mp_montgomery_reduce 
  * which uses the comba method to quickly calculate the columns of the
@@ -177,76 +177,77 @@ __ERR:mp_clear_multi (&x, &y, &u, &v, &B, &D, NULL);
  * Based on Algorithm 14.32 on pp.601 of HAC.
 */
 int
-fast_mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
+fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
 {
   int     ix, res, olduse;
   mp_word W[MP_WARRAY];
 
   /* get old used count */
-  olduse = a->used;
+  olduse = x->used;
 
   /* grow a as required */
-  if (a->alloc < m->used + 1) {
-    if ((res = mp_grow (a, m->used + 1)) != MP_OKAY) {
+  if (x->alloc < n->used + 1) {
+    if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) {
       return res;
     }
   }
 
   {
     register mp_word *_W;
-    register mp_digit *tmpa;
+    register mp_digit *tmpx;
 
     _W = W;
-    tmpa = a->dp;
+    tmpx = x->dp;
 
     /* copy the digits of a into W[0..a->used-1] */
-    for (ix = 0; ix < a->used; ix++) {
-      *_W++ = *tmpa++;
+    for (ix = 0; ix < x->used; ix++) {
+      *_W++ = *tmpx++;
     }
 
     /* zero the high words of W[a->used..m->used*2] */
-    for (; ix < m->used * 2 + 1; ix++) {
+    for (; ix < n->used * 2 + 1; ix++) {
       *_W++ = 0;
     }
   }
 
-  for (ix = 0; ix < m->used; ix++) {
-    /* ui = ai * m' mod b
+  for (ix = 0; ix < n->used; ix++) {
+    /* mu = ai * m' mod b
      *
      * We avoid a double precision multiplication (which isn't required)
-     * by casting the value down to a mp_digit.  Note this requires that W[ix-1] have
-     * the carry cleared (see after the inner loop)
+     * by casting the value down to a mp_digit.  Note this requires 
+     * that W[ix-1] have  the carry cleared (see after the inner loop)
      */
-    register mp_digit ui;
-    ui = (((mp_digit) (W[ix] & MP_MASK)) * mp) & MP_MASK;
+    register mp_digit mu;
+    mu = (((mp_digit) (W[ix] & MP_MASK)) * rho) & MP_MASK;
 
-    /* a = a + ui * m * b^i
+    /* a = a + mu * m * b**i
      *
      * This is computed in place and on the fly.  The multiplication
-     * by b^i is handled by offseting which columns the results
+     * by b**i is handled by offseting which columns the results
      * are added to.
      *
-     * Note the comba method normally doesn't handle carries in the inner loop
-     * In this case we fix the carry from the previous column since the Montgomery
-     * reduction requires digits of the result (so far) [see above] to work.  This is
-     * handled by fixing up one carry after the inner loop.  The carry fixups are done
-     * in order so after these loops the first m->used words of W[] have the carries
-     * fixed
+     * Note the comba method normally doesn't handle carries in the 
+     * inner loop In this case we fix the carry from the previous 
+     * column since the Montgomery reduction requires digits of the 
+     * result (so far) [see above] to work.  This is
+     * handled by fixing up one carry after the inner loop.  The 
+     * carry fixups are done in order so after these loops the 
+     * first m->used words of W[] have the carries fixed
      */
     {
       register int iy;
-      register mp_digit *tmpx;
+      register mp_digit *tmpn;
       register mp_word *_W;
 
       /* alias for the digits of the modulus */
-      tmpx = m->dp;
+      tmpn = n->dp;
 
       /* Alias for the columns set by an offset of ix */
       _W = W + ix;
 
       /* inner loop */
-      for (iy = 0; iy < m->used; iy++) {
-    *_W++ += ((mp_word) ui) * ((mp_word) * tmpx++);
+      for (iy = 0; iy < n->used; iy++) {
+          *_W++ += ((mp_word) mu) * ((mp_word) * tmpn++);
       }
     }
 
@@ -256,44 +257,44 @@ fast_mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
 
 
   {
-    register mp_digit *tmpa;
+    register mp_digit *tmpx;
     register mp_word *_W, *_W1;
 
     /* nox fix rest of carries */
     _W1 = W + ix;
     _W = W + ++ix;
 
-    for (; ix <= m->used * 2 + 1; ix++) {
+    for (; ix <= n->used * 2 + 1; ix++) {
       *_W++ += *_W1++ >> ((mp_word) DIGIT_BIT);
     }
 
-    /* copy out, A = A/b^n
+    /* copy out, A = A/b**n
      *
-     * The result is A/b^n but instead of converting from an array of mp_word
-     * to mp_digit than calling mp_rshd we just copy them in the right
-     * order
+     * The result is A/b**n but instead of converting from an 
+     * array of mp_word to mp_digit than calling mp_rshd 
+     * we just copy them in the right order
      */
-    tmpa = a->dp;
-    _W = W + m->used;
+    tmpx = x->dp;
+    _W = W + n->used;
 
-    for (ix = 0; ix < m->used + 1; ix++) {
-      *tmpa++ = *_W++ & ((mp_word) MP_MASK);
+    for (ix = 0; ix < n->used + 1; ix++) {
+      *tmpx++ = *_W++ & ((mp_word) MP_MASK);
     }
 
     /* zero oldused digits, if the input a was larger than
      * m->used+1 we'll have to clear the digits */
     for (; ix < olduse; ix++) {
-      *tmpa++ = 0;
+      *tmpx++ = 0;
     }
   }
 
   /* set the max used and clamp */
-  a->used = m->used + 1;
-  mp_clamp (a);
+  x->used = n->used + 1;
+  mp_clamp (x);
 
   /* if A >= m then A = A - m */
-  if (mp_cmp_mag (a, m) != MP_LT) {
-    return s_mp_sub (a, m, a);
+  if (mp_cmp_mag (x, n) != MP_LT) {
+    return s_mp_sub (x, n, x);
   }
   return MP_OKAY;
 }
@@ -548,15 +549,17 @@ fast_s_mp_mul_high_digs (mp_int * a, mp_int * b, mp_int * c, int digs)
 
 /* fast squaring
  *
- * This is the comba method where the columns of the product are computed first
- * then the carries are computed.  This has the effect of making a very simple
- * inner loop that is executed the most
+ * This is the comba method where the columns of the product 
+ * are computed first then the carries are computed.  This 
+ * has the effect of making a very simple inner loop that 
+ * is executed the most
  *
  * W2 represents the outer products and W the inner.
  *
- * A further optimizations is made because the inner products are of the form
- * "A * B * 2".  The *2 part does not need to be computed until the end which is
- * good because 64-bit shifts are slow!
+ * A further optimizations is made because the inner 
+ * products are of the form "A * B * 2".  The *2 part does 
+ * not need to be computed until the end which is good 
+ * because 64-bit shifts are slow!
  *
  * Based on Algorithm 14.16 on pp.597 of HAC.
  *
@@ -580,26 +583,15 @@ fast_s_mp_sqr (mp_int * a, mp_int * b)
    * Note that there are two buffers.  Since squaring requires
    * a outter and inner product and the inner product requires
    * computing a product and doubling it (a relatively expensive
-   * op to perform n^2 times if you don't have to) the inner and
+   * op to perform n**2 times if you don't have to) the inner and
    * outer products are computed in different buffers.  This way
    * the inner product can be doubled using n doublings instead of
-   * n^2
+   * n**2
    */
   memset (W, 0, newused * sizeof (mp_word));
   memset (W2, 0, newused * sizeof (mp_word));
 
-/* note optimization
- * values in W2 are only written in even locations which means
- * we can collapse the array to 256 words [and fixup the memset above]
- * provided we also fix up the summations below.  Ideally
- * the fixup loop should be unrolled twice to handle the even/odd
- * cases, and then a final step to handle odd cases [e.g. newused == odd]
- *
- * This will not only save ~8*256 = 2KB of stack but lower the number of
- * operations required to finally fix up the columns
- */
-
-  /* This computes the inner product.  To simplify the inner N^2 loop
+  /* This computes the inner product.  To simplify the inner N**2 loop
    * the multiplication by two is done afterwards in the N loop.
    */
   for (ix = 0; ix < pa; ix++) {
@@ -633,18 +625,19 @@ fast_s_mp_sqr (mp_int * a, mp_int * b)
   }
 
   /* setup dest */
-  olduse = b->used;
+  olduse  = b->used;
   b->used = newused;
 
-  /* double first value, since the inner products are half of what they should be */
-  W[0] += W[0] + W2[0];
-
   /* now compute digits */
   {
     register mp_digit *tmpb;
 
-    tmpb = b->dp;
+    /* double first value, since the inner products are 
+     * half of what they should be 
+     */
+    W[0] += W[0] + W2[0];
 
+    tmpb = b->dp;
     for (ix = 1; ix < newused; ix++) {
       /* double/add next digit */
       W[ix] += W[ix] + W2[ix];
@@ -652,9 +645,13 @@ fast_s_mp_sqr (mp_int * a, mp_int * b)
       W[ix] = W[ix] + (W[ix - 1] >> ((mp_word) DIGIT_BIT));
       *tmpb++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
     }
+    /* set the last value.  Note even if the carry is zero 
+     * this is required since the next step will not zero 
+     * it if b originally had a value at b->dp[2*a.used]
+     */
     *tmpb++ = (mp_digit) (W[(newused) - 1] & ((mp_word) MP_MASK));
 
-    /* clear high */
+    /* clear high digits */
     for (; ix < olduse; ix++) {
       *tmpb++ = 0;
     }
@@ -684,7 +681,7 @@ fast_s_mp_sqr (mp_int * a, mp_int * b)
  */
 #include <tommath.h>
 
-/* computes a = 2^b 
+/* computes a = 2**b 
  *
  * Simple algorithm which zeroes the int, grows it then just sets one bit
  * as required.
@@ -1160,7 +1157,7 @@ mp_copy (mp_int * a, mp_int * b)
   int     res, n;
 
   /* if dst == src do nothing */
-  if (a == b || a->dp == b->dp) {
+  if (a == b) {
     return MP_OKAY;
   }
 
@@ -1219,11 +1216,15 @@ mp_count_bits (mp_int * a)
   int     r;
   mp_digit q;
 
+  /* shortcut */
   if (a->used == 0) {
     return 0;
   }
 
+  /* get number of digits and add that */
   r = (a->used - 1) * DIGIT_BIT;
+  
+  /* take the last digit and count the bits in it */
   q = a->dp[a->used - 1];
   while (q > ((mp_digit) 0)) {
     ++r;
@@ -1525,7 +1526,7 @@ mp_div_2 (mp_int * a, mp_int * b)
  */
 #include <tommath.h>
 
-/* shift right by a certain bit count (store quotient in c, remainder in d) */
+/* shift right by a certain bit count (store quotient in c, optional remainder in d) */
 int
 mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
 {
@@ -1592,7 +1593,6 @@ mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
     }
   }
   mp_clamp (c);
-  res = MP_OKAY;
   if (d != NULL) {
     mp_exch (&t, d);
   }
@@ -1602,8 +1602,8 @@ mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
 
 /* End: bn_mp_div_2d.c */
 
-/* Start: bn_mp_div_d.c */
-#line 0 "bn_mp_div_d.c"
+/* Start: bn_mp_div_3.c */
+#line 0 "bn_mp_div_3.c"
 /* LibTomMath, multiple-precision integer library -- Tom St Denis
  *
  * LibTomMath is library that provides for multiple-precision
@@ -1620,35 +1620,124 @@ mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
  */
 #include <tommath.h>
 
-/* single digit division */
+/* divide by three (based on routine from MPI and the GMP manual) */
 int
-mp_div_d (mp_int * a, mp_digit b, mp_int * c, mp_digit * d)
+mp_div_3 (mp_int * a, mp_int *c, mp_digit * d)
 {
-  mp_int  t, t2;
-  int     res;
+  mp_int   q;
+  mp_word  w, t;
+  mp_digit b;
+  int      res, ix;
+  
+  /* b = 2**DIGIT_BIT / 3 */
+  b = (((mp_word)1) << ((mp_word)DIGIT_BIT)) / ((mp_word)3);
 
-  if ((res = mp_init (&t)) != MP_OKAY) {
-    return res;
+  if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
+     return res;
   }
-
-  if ((res = mp_init (&t2)) != MP_OKAY) {
-    mp_clear (&t);
-    return res;
+  
+  q.used = a->used;
+  q.sign = a->sign;
+  w = 0;
+  for (ix = a->used - 1; ix >= 0; ix--) {
+     w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
+     
+     if (w >= 3) {
+        t = (w * ((mp_word)b)) >> ((mp_word)DIGIT_BIT);
+        w -= (t << ((mp_word)1)) + t;
+        while (w >= 3) {
+           t += 1;
+           w -= 3;
+        }
+      } else {
+        t = 0;
+      }
+      q.dp[ix] = t;
+  }
+  
+  if (d != NULL) {
+     *d = w;
+  }
+  
+  if (c != NULL) {
+     mp_clamp(&q);
+     mp_exch(&q, c);
   }
+  mp_clear(&q);
+  
+  return res;
+}
 
-  mp_set (&t, b);
-  res = mp_div (a, &t, c, &t2);
 
-  /* set remainder if not null */
+/* End: bn_mp_div_3.c */
+
+/* Start: bn_mp_div_d.c */
+#line 0 "bn_mp_div_d.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* single digit division (based on routine from MPI) */
+int
+mp_div_d (mp_int * a, mp_digit b, mp_int * c, mp_digit * d)
+{
+  mp_int  q;
+  mp_word w, t;
+  int     res, ix;
+  
+  if (b == 0) {
+     return MP_VAL;
+  }
+  
+  if (b == 3) {
+     return mp_div_3(a, c, d);
+  }
+  
+  if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
+     return res;
+  }
+  
+  q.used = a->used;
+  q.sign = a->sign;
+  w = 0;
+  for (ix = a->used - 1; ix >= 0; ix--) {
+     w = (w << ((mp_word)DIGIT_BIT)) | ((mp_word)a->dp[ix]);
+     
+     if (w >= b) {
+        t = w / b;
+        w = w % b;
+      } else {
+        t = 0;
+      }
+      q.dp[ix] = t;
+  }
+  
   if (d != NULL) {
-    *d = t2.dp[0];
+     *d = w;
   }
-
-  mp_clear (&t);
-  mp_clear (&t2);
+  
+  if (c != NULL) {
+     mp_clamp(&q);
+     mp_exch(&q, c);
+  }
+  mp_clear(&q);
+  
   return res;
 }
 
+
 /* End: bn_mp_div_d.c */
 
 /* Start: bn_mp_dr_is_modulus.c */
@@ -1708,7 +1797,7 @@ int mp_dr_is_modulus(mp_int *a)
  */
 #include <tommath.h>
 
-/* reduce "a" in place modulo "b" using the Diminished Radix algorithm.
+/* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
  *
  * Based on algorithm from the paper
  *
@@ -1717,111 +1806,68 @@ int mp_dr_is_modulus(mp_int *a)
  *          POSTECH Information Research Laboratories
  *
  * The modulus must be of a special format [see manual]
+ *
+ * Has been modified to use algorithm 7.10 from the LTM book instead
  */
 int
-mp_dr_reduce (mp_int * a, mp_int * b, mp_digit mp)
+mp_dr_reduce (mp_int * x, mp_int * n, mp_digit k)
 {
-  int     err, i, j, k;
-  mp_word r;
-  mp_digit mu, *tmpj, *tmpi;
-
-  /* k = digits in modulus */
-  k = b->used;
-
-  /* ensure that "a" has at least 2k digits */
-  if (a->alloc < k + k) {
-    if ((err = mp_grow (a, k + k)) != MP_OKAY) {
+  int      err, i, m;
+  mp_word  r;
+  mp_digit mu, *tmpx1, *tmpx2;
+  
+  /* m = digits in modulus */
+  m = n->used;
+  
+  /* ensure that "x" has at least 2m digits */
+  if (x->alloc < m + m) {
+    if ((err = mp_grow (x, m + m)) != MP_OKAY) {
       return err;
     }
   }
 
-  /* alias for a->dp[i] */
-  tmpi = a->dp + k + k - 1;
-
-  /* for (i = 2k - 1; i >= k; i = i - 1)
-   *
-   * This is the main loop of the reduction.  Note that at the end
-   * the words above position k are not zeroed as expected.  The end
-   * result is that the digits from 0 to k-1 are the residue.  So
-   * we have to clear those afterwards.
-   */
-  for (i = k + k - 1; i >= k; i = i - 1) {
-    /* x[i - 1 : i - k] += x[i]*mp */
-
-    /* x[i] * mp */
-    r = ((mp_word) *tmpi--) * ((mp_word) mp);
-
-    /* now add r to x[i-1:i-k]
-     *
-     * First add it to the first digit x[i-k] then form the carry
-     * then enter the main loop
-     */
-    j = i - k;
-
-    /* alias for a->dp[j] */
-    tmpj = a->dp + j;
-
-    /* add digit */
-    *tmpj += (mp_digit)(r & MP_MASK);
-
-    /* this is the carry */
-    mu = (r >> ((mp_word) DIGIT_BIT)) + (*tmpj >> DIGIT_BIT);
-
-    /* clear carry from a->dp[j]  */
-    *tmpj++ &= MP_MASK;
-
-    /* now add rest of the digits
-     *
-     * Note this is basically a simple single digit addition to
-     * a larger multiple digit number.  This is optimized somewhat
-     * because the propagation of carries is not likely to move
-     * more than a few digits.
-     *
-     */
-    for (++j; mu != 0 && j <= (i - 1); ++j) {
-      *tmpj   += mu;
-      mu       = *tmpj >> DIGIT_BIT;
-      *tmpj++ &= MP_MASK;
-    }
-
-    /* if final carry */
-    if (mu != 0) {
-      /* add mp to this to correct */
-      j = i - k;
-      tmpj = a->dp + j;
-
-      *tmpj += mp;
-      mu = *tmpj >> DIGIT_BIT;
-      *tmpj++ &= MP_MASK;
-
-      /* now handle carries */
-      for (++j; mu != 0 && j <= (i - 1); j++) {
-          *tmpj   += mu;
-          mu       = *tmpj >> DIGIT_BIT;
-          *tmpj++ &= MP_MASK;
-      }
-    }
+/* top of loop, this is where the code resumes if 
+ * another reduction pass is required.
+ */
+top:
+  /* aliases for digits */
+  /* alias for lower half of x */
+  tmpx1 = x->dp;
+  
+  /* alias for upper half of x, or x/B**m */
+  tmpx2 = x->dp + m;
+  
+  /* set carry to zero */
+  mu = 0;
+  
+  /* compute (x mod B**m) + mp * [x/B**m] inline and inplace */
+  for (i = 0; i < m; i++) {
+      r         = ((mp_word)*tmpx2++) * ((mp_word)k) + *tmpx1 + mu;
+      *tmpx1++  = r & MP_MASK;
+      mu        = r >> ((mp_word)DIGIT_BIT);
   }
-
-  /* zero words above k */
-  tmpi = a->dp + k;
-  for (i = k; i < a->used; i++) {
-      *tmpi++ = 0;
+  
+  /* set final carry */
+  *tmpx1++ = mu;
+  
+  /* zero words above m */
+  for (i = m + 1; i < x->used; i++) {
+      *tmpx1++ = 0;
   }
 
   /* clamp, sub and return */
-  mp_clamp (a);
+  mp_clamp (x);
 
-  /* if a >= b [b == modulus] then subtract the modulus to fix up */
-  if (mp_cmp_mag (a, b) != MP_LT) {
-    return s_mp_sub (a, b, a);
+  /* if x >= n then subtract and reduce again 
+   * Each successive "recursion" makes the input smaller and smaller.
+   */
+  if (mp_cmp_mag (x, n) != MP_LT) {
+    s_mp_sub(x, n, x);
+    goto top;
   }
   return MP_OKAY;
 }
 
-
-
-
 /* End: bn_mp_dr_reduce.c */
 
 /* Start: bn_mp_dr_setup.c */
@@ -1848,7 +1894,8 @@ void mp_dr_setup(mp_int *a, mp_digit *d)
    /* the casts are required if DIGIT_BIT is one less than
     * the number of bits in a mp_digit [e.g. DIGIT_BIT==31]
     */
-   *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) - ((mp_word)a->dp[0]));
+   *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) - 
+        ((mp_word)a->dp[0]));
 }
 
 
@@ -1905,7 +1952,7 @@ mp_exch (mp_int * a, mp_int * b)
  */
 #include <tommath.h>
 
-/* calculate c = a^b  using a square-multiply algorithm */
+/* calculate c = a**b  using a square-multiply algorithm */
 int
 mp_expt_d (mp_int * a, mp_digit b, mp_int * c)
 {
@@ -1962,7 +2009,6 @@ mp_expt_d (mp_int * a, mp_digit b, mp_int * c)
  */
 #include <tommath.h>
 
-static int f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y);
 
 /* this is a shell function that calls either the normal or Montgomery
  * exptmod functions.  Originally the call to the montgomery code was
@@ -2003,28 +2049,65 @@ mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
         return err;
      }
 
-     /* and now compute (1/G)^|X| instead of G^X [X < 0] */
+     /* and now compute (1/G)**|X| instead of G**X [X < 0] */
      err = mp_exptmod(&tmpG, &tmpX, P, Y);
      mp_clear_multi(&tmpG, &tmpX, NULL);
      return err;
   }
 
-
   dr = mp_dr_is_modulus(P);
+  if (dr == 0) {
+     dr = mp_reduce_is_2k(P) << 1;
+  }
+  
   /* if the modulus is odd use the fast method */
-  if ((mp_isodd (P) == 1 || dr == 1) && P->used > 4) {
+  if ((mp_isodd (P) == 1 || dr !=  0) && P->used > 4) {
     return mp_exptmod_fast (G, X, P, Y, dr);
   } else {
-    return f_mp_exptmod (G, X, P, Y);
+    return s_mp_exptmod (G, X, P, Y);
   }
 }
 
-static int
-f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
+
+/* End: bn_mp_exptmod.c */
+
+/* Start: bn_mp_exptmod_fast.c */
+#line 0 "bn_mp_exptmod_fast.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* computes Y == G^X mod P, HAC pp.616, Algorithm 14.85
+ *
+ * Uses a left-to-right k-ary sliding window to compute the modular exponentiation.
+ * The value of k changes based on the size of the exponent.
+ *
+ * Uses Montgomery or Diminished Radix reduction [whichever appropriate]
+ */
+int
+mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
 {
-  mp_int  M[256], res, mu;
-  mp_digit buf;
+  mp_int  M[256], res;
+  mp_digit buf, mp;
   int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
+  
+  /* use a pointer to the reduction algorithm.  This allows us to use
+   * one of many reduction algorithms without modding the guts of
+   * the code with if statements everywhere.  
+   */
+  int     (*redux)(mp_int*,mp_int*,mp_digit);
 
   /* find window size */
   x = mp_count_bits (X);
@@ -2045,14 +2128,15 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
   }
 
 #ifdef MP_LOW_MEM
-    if (winsize > 5) {
-       winsize = 5;
-    }
+  if (winsize > 5) {
+     winsize = 5;
+  }
 #endif
 
+
   /* init G array */
   for (x = 0; x < (1 << winsize); x++) {
-    if ((err = mp_init_size (&M[x], 1)) != MP_OKAY) {
+    if ((err = mp_init (&M[x])) != MP_OKAY) {
       for (y = 0; y < x; y++) {
         mp_clear (&M[y]);
       }
@@ -2060,12 +2144,36 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
     }
   }
 
-  /* create mu, used for Barrett reduction */
-  if ((err = mp_init (&mu)) != MP_OKAY) {
-    goto __M;
+  /* determine and setup reduction code */
+  if (redmode == 0) {
+     /* now setup montgomery  */
+     if ((err = mp_montgomery_setup (P, &mp)) != MP_OKAY) {
+        goto __M;
+     }
+     
+     /* automatically pick the comba one if available (saves quite a few calls/ifs) */
+     if (((P->used * 2 + 1) < MP_WARRAY) &&
+          P->used < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
+        redux = fast_mp_montgomery_reduce;
+     } else {
+        /* use slower baselien method */
+        redux = mp_montgomery_reduce;
+     }
+  } else if (redmode == 1) {
+     /* setup DR reduction */
+     mp_dr_setup(P, &mp);
+     redux = mp_dr_reduce;
+  } else {
+     /* setup 2k reduction */
+     if ((err = mp_reduce_2k_setup(P, &mp)) != MP_OKAY) {
+        goto __M;
+     }
+     redux = mp_reduce_2k;
   }
-  if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) {
-    goto __MU;
+
+  /* setup result */
+  if ((err = mp_init (&res)) != MP_OKAY) {
+    goto __RES;
   }
 
   /* create M table
@@ -2074,46 +2182,55 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
    *
    * The first half of the table is not computed though accept for M[0] and M[1]
    */
-  if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) {
-    goto __MU;
+
+  if (redmode == 0) {
+     /* now we need R mod m */
+     if ((err = mp_montgomery_calc_normalization (&res, P)) != MP_OKAY) {
+       goto __RES;
+     }
+
+     /* now set M[1] to G * R mod m */
+     if ((err = mp_mulmod (G, &res, P, &M[1])) != MP_OKAY) {
+       goto __RES;
+     }
+  } else {
+     mp_set(&res, 1);
+     if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) {
+        goto __RES;
+     }
   }
 
   /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */
   if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
-    goto __MU;
+    goto __RES;
   }
 
   for (x = 0; x < (winsize - 1); x++) {
     if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
-      goto __MU;
+      goto __RES;
     }
-    if ((err = mp_reduce (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) {
-      goto __MU;
+    if ((err = redux (&M[1 << (winsize - 1)], P, mp)) != MP_OKAY) {
+      goto __RES;
     }
   }
 
   /* create upper table */
   for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
     if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
-      goto __MU;
+      goto __RES;
     }
-    if ((err = mp_reduce (&M[x], P, &mu)) != MP_OKAY) {
-      goto __MU;
+    if ((err = redux (&M[x], P, mp)) != MP_OKAY) {
+      goto __RES;
     }
   }
 
-  /* setup result */
-  if ((err = mp_init (&res)) != MP_OKAY) {
-    goto __MU;
-  }
-  mp_set (&res, 1);
-
   /* set initial mode and bit cnt */
   mode   = 0;
   bitcnt = 1;
   buf    = 0;
   digidx = X->used - 1;
-  bitcpy = bitbuf = 0;
+  bitcpy = 0;
+  bitbuf = 0;
 
   for (;;) {
     /* grab next digit as required */
@@ -2126,7 +2243,7 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
     }
 
     /* grab the next msb from the exponent */
-    y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
+    y = (mp_digit)(buf >> (DIGIT_BIT - 1)) & 1;
     buf <<= (mp_digit)1;
 
     /* if the bit is zero and mode == 0 then we ignore it
@@ -2134,15 +2251,16 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
      * in the exponent.  Technically this opt is not required but it
      * does lower the # of trivial squaring/reductions used
      */
-    if (mode == 0 && y == 0)
+    if (mode == 0 && y == 0) {
       continue;
+    }
 
     /* if the bit is zero and mode == 1 then we square */
     if (mode == 1 && y == 0) {
       if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
         goto __RES;
       }
-      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+      if ((err = redux (&res, P, mp)) != MP_OKAY) {
         goto __RES;
       }
       continue;
@@ -2159,21 +2277,22 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
         if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
           goto __RES;
         }
-        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+        if ((err = redux (&res, P, mp)) != MP_OKAY) {
           goto __RES;
         }
       }
 
       /* then multiply */
       if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) {
-        goto __MU;
+        goto __RES;
       }
-      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
-        goto __MU;
+      if ((err = redux (&res, P, mp)) != MP_OKAY) {
+        goto __RES;
       }
 
       /* empty window and reset */
-      bitcpy = bitbuf = 0;
+      bitcpy = 0;
+      bitbuf = 0;
       mode = 1;
     }
   }
@@ -2185,7 +2304,7 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
       if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
         goto __RES;
       }
-      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+      if ((err = redux (&res, P, mp)) != MP_OKAY) {
         goto __RES;
       }
 
@@ -2195,256 +2314,7 @@ f_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
         if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) {
           goto __RES;
         }
-        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
-          goto __RES;
-        }
-      }
-    }
-  }
-
-  mp_exch (&res, Y);
-  err = MP_OKAY;
-__RES:mp_clear (&res);
-__MU:mp_clear (&mu);
-__M:
-  for (x = 0; x < (1 << winsize); x++) {
-    mp_clear (&M[x]);
-  }
-  return err;
-}
-
-/* End: bn_mp_exptmod.c */
-
-/* Start: bn_mp_exptmod_fast.c */
-#line 0 "bn_mp_exptmod_fast.c"
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
- *
- * LibTomMath is library that provides for multiple-precision
- * integer arithmetic as well as number theoretic functionality.
- *
- * The library is designed directly after the MPI library by
- * Michael Fromberger but has been written from scratch with
- * additional optimizations in place.
- *
- * The library is free for all purposes without any express
- * guarantee it works.
- *
- * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
- */
-#include <tommath.h>
-
-/* computes Y == G^X mod P, HAC pp.616, Algorithm 14.85
- *
- * Uses a left-to-right k-ary sliding window to compute the modular exponentiation.
- * The value of k changes based on the size of the exponent.
- *
- * Uses Montgomery or Diminished Radix reduction [whichever appropriate]
- */
-int
-mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
-{
-  mp_int  M[256], res;
-  mp_digit buf, mp;
-  int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
-  int     (*redux)(mp_int*,mp_int*,mp_digit);
-
-  /* find window size */
-  x = mp_count_bits (X);
-  if (x <= 7) {
-    winsize = 2;
-  } else if (x <= 36) {
-    winsize = 3;
-  } else if (x <= 140) {
-    winsize = 4;
-  } else if (x <= 450) {
-    winsize = 5;
-  } else if (x <= 1303) {
-    winsize = 6;
-  } else if (x <= 3529) {
-    winsize = 7;
-  } else {
-    winsize = 8;
-  }
-
-#ifdef MP_LOW_MEM
-  if (winsize > 5) {
-     winsize = 5;
-  }
-#endif
-
-
-  /* init G array */
-  for (x = 0; x < (1 << winsize); x++) {
-    if ((err = mp_init (&M[x])) != MP_OKAY) {
-      for (y = 0; y < x; y++) {
-        mp_clear (&M[y]);
-      }
-      return err;
-    }
-  }
-
-  if (redmode == 0) {
-     /* now setup montgomery  */
-     if ((err = mp_montgomery_setup (P, &mp)) != MP_OKAY) {
-        goto __M;
-     }
-     
-     /* automatically pick the comba one if available (saves quite a few calls/ifs) */
-     if ( ((P->used * 2 + 1) < MP_WARRAY) &&
-          P->used < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
-        redux = fast_mp_montgomery_reduce;
-     } else {
-        /* use slower baselien method */
-        redux = mp_montgomery_reduce;
-     }
-  } else {
-     /* setup DR reduction */
-     mp_dr_setup(P, &mp);
-     redux = mp_dr_reduce;
-  }
-
-  /* setup result */
-  if ((err = mp_init (&res)) != MP_OKAY) {
-    goto __RES;
-  }
-
-  /* create M table
-   *
-   * The M table contains powers of the input base, e.g. M[x] = G^x mod P
-   *
-   * The first half of the table is not computed though accept for M[0] and M[1]
-   */
-
-  if (redmode == 0) {
-     /* now we need R mod m */
-     if ((err = mp_montgomery_calc_normalization (&res, P)) != MP_OKAY) {
-       goto __RES;
-     }
-
-     /* now set M[1] to G * R mod m */
-     if ((err = mp_mulmod (G, &res, P, &M[1])) != MP_OKAY) {
-       goto __RES;
-     }
-  } else {
-     mp_set(&res, 1);
-     if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) {
-        goto __RES;
-     }
-  }
-
-  /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */
-  if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
-    goto __RES;
-  }
-
-  for (x = 0; x < (winsize - 1); x++) {
-    if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
-      goto __RES;
-    }
-    if ((err = redux (&M[1 << (winsize - 1)], P, mp)) != MP_OKAY) {
-      goto __RES;
-    }
-  }
-
-  /* create upper table */
-  for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
-    if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
-      goto __RES;
-    }
-    if ((err = redux (&M[x], P, mp)) != MP_OKAY) {
-      goto __RES;
-    }
-  }
-
-  /* set initial mode and bit cnt */
-  mode   = 0;
-  bitcnt = 1;
-  buf    = 0;
-  digidx = X->used - 1;
-  bitcpy = bitbuf = 0;
-
-  for (;;) {
-    /* grab next digit as required */
-    if (--bitcnt == 0) {
-      if (digidx == -1) {
-        break;
-      }
-      buf = X->dp[digidx--];
-      bitcnt = (int) DIGIT_BIT;
-    }
-
-    /* grab the next msb from the exponent */
-    y = (mp_digit)(buf >> (DIGIT_BIT - 1)) & 1;
-    buf <<= (mp_digit)1;
-
-    /* if the bit is zero and mode == 0 then we ignore it
-     * These represent the leading zero bits before the first 1 bit
-     * in the exponent.  Technically this opt is not required but it
-     * does lower the # of trivial squaring/reductions used
-     */
-    if (mode == 0 && y == 0) {
-      continue;
-    }
-
-    /* if the bit is zero and mode == 1 then we square */
-    if (mode == 1 && y == 0) {
-      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
-        goto __RES;
-      }
-      if ((err = redux (&res, P, mp)) != MP_OKAY) {
-        goto __RES;
-      }
-      continue;
-    }
-
-    /* else we add it to the window */
-    bitbuf |= (y << (winsize - ++bitcpy));
-    mode = 2;
-
-    if (bitcpy == winsize) {
-      /* ok window is filled so square as required and multiply  */
-      /* square first */
-      for (x = 0; x < winsize; x++) {
-        if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
-          goto __RES;
-        }
-        if ((err = redux (&res, P, mp)) != MP_OKAY) {
-          goto __RES;
-        }
-      }
-
-      /* then multiply */
-      if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) {
-        goto __RES;
-      }
-      if ((err = redux (&res, P, mp)) != MP_OKAY) {
-        goto __RES;
-      }
-
-      /* empty window and reset */
-      bitcpy = bitbuf = 0;
-      mode = 1;
-    }
-  }
-
-  /* if bits remain then square/multiply */
-  if (mode == 2 && bitcpy > 0) {
-    /* square then multiply if the bit is set */
-    for (x = 0; x < bitcpy; x++) {
-      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
-        goto __RES;
-      }
-      if ((err = redux (&res, P, mp)) != MP_OKAY) {
-        goto __RES;
-      }
-
-      bitbuf <<= 1;
-      if ((bitbuf & (1 << winsize)) != 0) {
-        /* then multiply */
-        if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) {
-          goto __RES;
-        }
-        if ((err = redux (&res, P, mp)) != MP_OKAY) {
+        if ((err = redux (&res, P, mp)) != MP_OKAY) {
           goto __RES;
         }
       }
@@ -2452,7 +2322,7 @@ mp_exptmod_fast (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode)
   }
 
   if (redmode == 0) {
-     /* fixup result */
+     /* fixup result if Montgomery reduction is used */
      if ((err = mp_montgomery_reduce (&res, P, mp)) != MP_OKAY) {
        goto __RES;
      }
@@ -2668,7 +2538,7 @@ mp_init (mp_int * a)
     return MP_MEM;
   }
 
-  /* set the used to zero, allocated digit to the default precision
+  /* set the used to zero, allocated digits to the default precision
    * and sign to positive */
   a->used  = 0;
   a->alloc = MP_PREC;
@@ -3059,24 +2929,34 @@ __A1:mp_clear (&a1);
  */
 #include <tommath.h>
 
-/* c = |a| * |b| using Karatsuba Multiplication using three half size multiplications
- *
- * Let B represent the radix [e.g. 2**DIGIT_BIT] and let n represent half of the number of digits in the min(a,b)
- *
- * a = a1 * B^n + a0
- * b = b1 * B^n + b0
- *
- * Then, a * b => a1b1 * B^2n + ((a1 - b1)(a0 - b0) + a0b0 + a1b1) * B + a0b0
- *
- * Note that a1b1 and a0b0 are used twice and only need to be computed once.  So in total
- * three half size (half # of digit) multiplications are performed, a0b0, a1b1 and (a1-b1)(a0-b0)
- *
- * Note that a multiplication of half the digits requires 1/4th the number of single precision 
- * multiplications so in total after one call 25% of the single precision multiplications are saved.
- * Note also that the call to mp_mul can end up back in this function if the a0, a1, b0, or b1 are above
- * the threshold.  This is known as divide-and-conquer and leads to the famous O(N^lg(3)) or O(N^1.584) work which
- * is asymptopically lower than the standard O(N^2) that the baseline/comba methods use.  Generally though the 
- * overhead of this method doesn't pay off until a certain size (N ~ 80) is reached.
+/* c = |a| * |b| using Karatsuba Multiplication using 
+ * three half size multiplications
+ *
+ * Let B represent the radix [e.g. 2**DIGIT_BIT] and 
+ * let n represent half of the number of digits in 
+ * the min(a,b)
+ *
+ * a = a1 * B**n + a0
+ * b = b1 * B**n + b0
+ *
+ * Then, a * b => 
+   a1b1 * B**2n + ((a1 - a0)(b1 - b0) + a0b0 + a1b1) * B + a0b0
+ *
+ * Note that a1b1 and a0b0 are used twice and only need to be 
+ * computed once.  So in total three half size (half # of 
+ * digit) multiplications are performed, a0b0, a1b1 and 
+ * (a1-b1)(a0-b0)
+ *
+ * Note that a multiplication of half the digits requires
+ * 1/4th the number of single precision multiplications so in 
+ * total after one call 25% of the single precision multiplications 
+ * are saved.  Note also that the call to mp_mul can end up back 
+ * in this function if the a0, a1, b0, or b1 are above the threshold.  
+ * This is known as divide-and-conquer and leads to the famous 
+ * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than 
+ * the standard O(N**2) that the baseline/comba methods use.  
+ * Generally though the overhead of this method doesn't pay off 
+ * until a certain size (N ~ 80) is reached.
  */
 int
 mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
@@ -3146,14 +3026,15 @@ mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
     }
   }
 
-  /* only need to clamp the lower words since by definition the upper words x1/y1 must
-   * have a known number of digits
+  /* only need to clamp the lower words since by definition the 
+   * upper words x1/y1 must have a known number of digits
    */
   mp_clamp (&x0);
   mp_clamp (&y0);
 
   /* now calc the products x0y0 and x1y1 */
-  if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY)  /* after this x0 is no longer required, free temp [x0==t2]! */
+  /* after this x0 is no longer required, free temp [x0==t2]! */
+  if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY)  
     goto X1Y1;          /* x0y0 = x0*y0 */
   if (mp_mul (&x1, &y1, &x1y1) != MP_OKAY)
     goto X1Y1;          /* x1y1 = x1*y1 */
@@ -3216,10 +3097,12 @@ ERR:
  */
 #include <tommath.h>
 
-/* Karatsuba squaring, computes b = a*a using three half size squarings
+/* Karatsuba squaring, computes b = a*a using three 
+ * half size squarings
  *
- * See comments of mp_karatsuba_mul for details.  It is essentially the same algorithm
- * but merely tuned to perform recursive squarings.
+ * See comments of mp_karatsuba_mul for details.  It 
+ * is essentially the same algorithm but merely 
+ * tuned to perform recursive squarings.
  */
 int
 mp_karatsuba_sqr (mp_int * a, mp_int * b)
@@ -3276,32 +3159,32 @@ mp_karatsuba_sqr (mp_int * a, mp_int * b)
 
   /* now calc the products x0*x0 and x1*x1 */
   if (mp_sqr (&x0, &x0x0) != MP_OKAY)
-    goto X1X1;                  /* x0x0 = x0*x0 */
+    goto X1X1;           /* x0x0 = x0*x0 */
   if (mp_sqr (&x1, &x1x1) != MP_OKAY)
-    goto X1X1;                  /* x1x1 = x1*x1 */
+    goto X1X1;           /* x1x1 = x1*x1 */
 
-  /* now calc (x1-x0)^2 */
+  /* now calc (x1-x0)**2 */
   if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = x1 - x0 */
+    goto X1X1;           /* t1 = x1 - x0 */
   if (mp_sqr (&t1, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = (x1 - x0) * (x1 - x0) */
+    goto X1X1;           /* t1 = (x1 - x0) * (x1 - x0) */
 
   /* add x0y0 */
   if (s_mp_add (&x0x0, &x1x1, &t2) != MP_OKAY)
-    goto X1X1;                  /* t2 = x0y0 + x1y1 */
+    goto X1X1;           /* t2 = x0x0 + x1x1 */
   if (mp_sub (&t2, &t1, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = x0y0 + x1y1 - (x1-x0)*(y1-y0) */
+    goto X1X1;           /* t1 = x0x0 + x1x1 - (x1-x0)*(x1-x0) */
 
   /* shift by B */
   if (mp_lshd (&t1, B) != MP_OKAY)
-    goto X1X1;                  /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */
+    goto X1X1;           /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */
   if (mp_lshd (&x1x1, B * 2) != MP_OKAY)
-    goto X1X1;                  /* x1y1 = x1y1 << 2*B */
+    goto X1X1;           /* x1x1 = x1x1 << 2*B */
 
   if (mp_add (&x0x0, &t1, &t1) != MP_OKAY)
-    goto X1X1;                  /* t1 = x0y0 + t1 */
+    goto X1X1;           /* t1 = x0x0 + t1 */
   if (mp_add (&t1, &x1x1, b) != MP_OKAY)
-    goto X1X1;                  /* t1 = x0y0 + t1 + x1y1 */
+    goto X1X1;           /* t1 = x0x0 + t1 + x1x1 */
 
   err = MP_OKAY;
 
@@ -3401,29 +3284,29 @@ mp_lshd (mp_int * a, int b)
   }
 
   {
-    register mp_digit *tmpa, *tmpaa;
+    register mp_digit *top, *bottom;
 
-    /* increment the used by the shift amount than copy upwards */
+    /* increment the used by the shift amount then copy upwards */
     a->used += b;
 
     /* top */
-    tmpa = a->dp + a->used - 1;
+    top = a->dp + a->used - 1;
 
     /* base */
-    tmpaa = a->dp + a->used - 1 - b;
+    bottom = a->dp + a->used - 1 - b;
 
     /* much like mp_rshd this is implemented using a sliding window
      * except the window goes the otherway around.  Copying from
      * the bottom to the top.  see bn_mp_rshd.c for more info.
      */
     for (x = a->used - 1; x >= b; x--) {
-      *tmpa-- = *tmpaa--;
+      *top-- = *bottom--;
     }
 
     /* zero the lower digits */
-    tmpa = a->dp;
+    top = a->dp;
     for (x = 0; x < b; x++) {
-      *tmpa++ = 0;
+      *top++ = 0;
     }
   }
   return MP_OKAY;
@@ -3555,36 +3438,10 @@ mp_mod_2d (mp_int * a, int b, mp_int * c)
 int
 mp_mod_d (mp_int * a, mp_digit b, mp_digit * c)
 {
-  mp_int  t, t2;
-  int     res;
+  return mp_div_d(a, b, NULL, c);
+}
 
-
-  if ((res = mp_init (&t)) != MP_OKAY) {
-    return res;
-  }
-
-  if ((res = mp_init (&t2)) != MP_OKAY) {
-    mp_clear (&t);
-    return res;
-  }
-
-  mp_set (&t, b);
-  mp_div (a, &t, NULL, &t2);
-
-  if (t2.sign == MP_NEG) {
-    if ((res = mp_add_d (&t2, b, &t2)) != MP_OKAY) {
-      mp_clear (&t);
-      mp_clear (&t2);
-      return res;
-    }
-  }
-  *c = t2.dp[0];
-  mp_clear (&t);
-  mp_clear (&t2);
-  return MP_OKAY;
-}
-
-/* End: bn_mp_mod_d.c */
+/* End: bn_mp_mod_d.c */
 
 /* Start: bn_mp_montgomery_calc_normalization.c */
 #line 0 "bn_mp_montgomery_calc_normalization.c"
@@ -3662,12 +3519,12 @@ mp_montgomery_calc_normalization (mp_int * a, mp_int * b)
  */
 #include <tommath.h>
 
-/* computes xR^-1 == x (mod N) via Montgomery Reduction */
+/* computes xR**-1 == x (mod N) via Montgomery Reduction */
 int
-mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
+mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
 {
   int     ix, res, digs;
-  mp_digit ui;
+  mp_digit mu;
 
   /* can the fast reduction [comba] method be used?
    *
@@ -3675,55 +3532,60 @@ mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
    * than the available columns [255 per default] since carries
    * are fixed up in the inner loop.
    */
-  digs = m->used * 2 + 1;
-  if ((digs < MP_WARRAY)
-      && m->used < (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
-    return fast_mp_montgomery_reduce (a, m, mp);
+  digs = n->used * 2 + 1;
+  if ((digs < MP_WARRAY) && 
+      n->used < 
+      (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
+    return fast_mp_montgomery_reduce (x, n, rho);
   }
 
   /* grow the input as required */
-  if (a->alloc < m->used * 2 + 1) {
-    if ((res = mp_grow (a, m->used * 2 + 1)) != MP_OKAY) {
+  if (x->alloc < digs) {
+    if ((res = mp_grow (x, digs)) != MP_OKAY) {
       return res;
     }
   }
-  a->used = m->used * 2 + 1;
+  x->used = digs;
 
-  for (ix = 0; ix < m->used; ix++) {
-    /* ui = ai * m' mod b */
-    ui = (a->dp[ix] * mp) & MP_MASK;
+  for (ix = 0; ix < n->used; ix++) {
+    /* mu = ai * m' mod b */
+    mu = (x->dp[ix] * rho) & MP_MASK;
 
-    /* a = a + ui * m * b^i */
+    /* a = a + mu * m * b**i */
     {
       register int iy;
-      register mp_digit *tmpx, *tmpy, mu;
+      register mp_digit *tmpn, *tmpx, u;
       register mp_word r;
 
       /* aliases */
-      tmpx = m->dp;
-      tmpy = a->dp + ix;
-
-      mu = 0;
-      for (iy = 0; iy < m->used; iy++) {
-        r = ((mp_word) ui) * ((mp_word) * tmpx++) + ((mp_word) mu) + ((mp_word) * tmpy);
-        mu = (r >> ((mp_word) DIGIT_BIT));
-        *tmpy++ = (r & ((mp_word) MP_MASK));
+      tmpn = n->dp;
+      tmpx = x->dp + ix;
+
+      /* set the carry to zero */
+      u = 0;
+      
+      /* Multiply and add in place */
+      for (iy = 0; iy < n->used; iy++) {
+        r = ((mp_word) mu) * ((mp_word) * tmpn++) + 
+            ((mp_word) u) + ((mp_word) * tmpx);
+        u = (r >> ((mp_word) DIGIT_BIT));
+        *tmpx++ = (r & ((mp_word) MP_MASK));
       }
       /* propagate carries */
-      while (mu) {
-        *tmpy += mu;
-        mu = (*tmpy >> DIGIT_BIT) & 1;
-        *tmpy++ &= MP_MASK;
+      while (u) {
+        *tmpx += u;
+        u = *tmpx >> DIGIT_BIT;
+        *tmpx++ &= MP_MASK;
       }
     }
   }
 
-  /* A = A/b^n */
-  mp_rshd (a, m->used);
+  /* x = x/b**n.used */
+  mp_rshd (x, n->used);
 
   /* if A >= m then A = A - m */
-  if (mp_cmp_mag (a, m) != MP_LT) {
-    return s_mp_sub (a, m, a);
+  if (mp_cmp_mag (x, n) != MP_LT) {
+    return s_mp_sub (x, n, x);
   }
 
   return MP_OKAY;
@@ -3751,38 +3613,38 @@ mp_montgomery_reduce (mp_int * a, mp_int * m, mp_digit mp)
 
 /* setups the montgomery reduction stuff */
 int
-mp_montgomery_setup (mp_int * a, mp_digit * mp)
+mp_montgomery_setup (mp_int * n, mp_digit * rho)
 {
   mp_digit x, b;
 
-/* fast inversion mod 2^k
+/* fast inversion mod 2**k
  *
  * Based on the fact that
  *
- * XA = 1 (mod 2^n)  =>  (X(2-XA)) A = 1 (mod 2^2n)
- *                   =>  2*X*A - X*X*A*A = 1
- *                   =>  2*(1) - (1)     = 1
+ * XA = 1 (mod 2**n)  =>  (X(2-XA)) A = 1 (mod 2**2n)
+ *                    =>  2*X*A - X*X*A*A = 1
+ *                    =>  2*(1) - (1)     = 1
  */
-  b = a->dp[0];
+  b = n->dp[0];
 
   if ((b & 1) == 0) {
     return MP_VAL;
   }
 
-  x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2^4 */
-  x *= 2 - b * x;               /* here x*a==1 mod 2^8 */
+  x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2**4 */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**8 */
 #if !defined(MP_8BIT)
-  x *= 2 - b * x;               /* here x*a==1 mod 2^16; each step doubles the nb of bits */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**16 */
 #endif
 #if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT))
-  x *= 2 - b * x;               /* here x*a==1 mod 2^32 */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**32 */
 #endif
 #ifdef MP_64BIT
-  x *= 2 - b * x;               /* here x*a==1 mod 2^64 */
+  x *= 2 - b * x;               /* here x*a==1 mod 2**64 */
 #endif
 
-  /* t = -1/m mod b */
-  *mp = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
+  /* rho = -1/m mod b */
+  *rho = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
 
   return MP_OKAY;
 }
@@ -3813,19 +3675,24 @@ mp_mul (mp_int * a, mp_int * b, mp_int * c)
 {
   int     res, neg;
   neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
-  if (MIN (a->used, b->used) > KARATSUBA_MUL_CUTOFF) {
+  
+  if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) {
+    res = mp_toom_mul(a, b, c);
+  } else if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) {
     res = mp_karatsuba_mul (a, b, c);
   } else {
 
     /* can we use the fast multiplier?
      *
-     * The fast multiplier can be used if the output will have less than
-     * MP_WARRAY digits and the number of digits won't affect carry propagation
+     * The fast multiplier can be used if the output will 
+     * have less than MP_WARRAY digits and the number of 
+     * digits won't affect carry propagation
      */
     int     digs = a->used + b->used + 1;
 
-    if ((digs < MP_WARRAY)
-        && MIN(a->used, b->used) <= (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
+    if ((digs < MP_WARRAY) &&
+        MIN(a->used, b->used) <= 
+        (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) {
       res = fast_s_mp_mul_digs (a, b, c, digs);
     } else {
       res = s_mp_mul (a, b, c);
@@ -4892,22 +4759,8 @@ mp_read_unsigned_bin (mp_int * a, unsigned char *b, int c)
  */
 #include <tommath.h>
 
-/* pre-calculate the value required for Barrett reduction
- * For a given modulus "b" it calulates the value required in "a"
- */
-int
-mp_reduce_setup (mp_int * a, mp_int * b)
-{
-  int     res;
-  
-  if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) {
-    return res;
-  }
-  res = mp_div (a, b, a, NULL);
-  return res;
-}
-
-/* reduces x mod m, assumes 0 < x < m^2, mu is precomputed via mp_reduce_setup
+/* reduces x mod m, assumes 0 < x < m**2, mu is 
+ * precomputed via mp_reduce_setup.
  * From HAC pp.604 Algorithm 14.42
  */
 int
@@ -4916,11 +4769,12 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
   mp_int  q;
   int     res, um = m->used;
 
+  /* q = x */
   if ((res = mp_init_copy (&q, x)) != MP_OKAY) {
     return res;
   }
 
-  /* q1 = x / b^(k-1)  */
+  /* q1 = x / b**(k-1)  */
   mp_rshd (&q, um - 1);         
 
   /* according to HAC this is optimization is ok */
@@ -4934,15 +4788,15 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
     }
   }
 
-  /* q3 = q2 / b^(k+1) */
+  /* q3 = q2 / b**(k+1) */
   mp_rshd (&q, um + 1);         
 
-  /* x = x mod b^(k+1), quick (no division) */
+  /* x = x mod b**(k+1), quick (no division) */
   if ((res = mp_mod_2d (x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) {
     goto CLEANUP;
   }
 
-  /* q = q * m mod b^(k+1), quick (no division) */
+  /* q = q * m mod b**(k+1), quick (no division) */
   if ((res = s_mp_mul_digs (&q, m, &q, um + 1)) != MP_OKAY) {
     goto CLEANUP;
   }
@@ -4952,7 +4806,7 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
     goto CLEANUP;
   }
 
-  /* If x < 0, add b^(k+1) to it */
+  /* If x < 0, add b**(k+1) to it */
   if (mp_cmp_d (x, 0) == MP_LT) {
     mp_set (&q, 1);
     if ((res = mp_lshd (&q, um + 1)) != MP_OKAY)
@@ -4967,7 +4821,7 @@ mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
       break;
     }
   }
-
+  
 CLEANUP:
   mp_clear (&q);
 
@@ -4976,6 +4830,190 @@ CLEANUP:
 
 /* End: bn_mp_reduce.c */
 
+/* Start: bn_mp_reduce_2k.c */
+#line 0 "bn_mp_reduce_2k.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* reduces a modulo n where n is of the form 2**p - k */
+int
+mp_reduce_2k(mp_int *a, mp_int *n, mp_digit k)
+{
+   mp_int q;
+   int    p, res;
+   
+   if ((res = mp_init(&q)) != MP_OKAY) {
+      return res;
+   }
+   
+   p = mp_count_bits(n);    
+top:
+   /* q = a/2**p, a = a mod 2**p */
+   if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) {
+      goto ERR;
+   }
+   
+   if (k != 1) {
+      /* q = q * k */
+      if ((res = mp_mul_d(&q, k, &q)) != MP_OKAY) { 
+         goto ERR;
+      }
+   }
+   
+   /* a = a + q */
+   if ((res = s_mp_add(a, &q, a)) != MP_OKAY) {
+      goto ERR;
+   }
+   
+   if (mp_cmp_mag(a, n) != MP_LT) {
+      s_mp_sub(a, n, a);
+      goto top;
+   }
+   
+ERR:
+   mp_clear(&q);
+   return res;
+}
+
+
+/* End: bn_mp_reduce_2k.c */
+
+/* Start: bn_mp_reduce_2k_setup.c */
+#line 0 "bn_mp_reduce_2k_setup.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* determines the setup value */
+int 
+mp_reduce_2k_setup(mp_int *a, mp_digit *d)
+{
+   int res, p;
+   mp_int tmp;
+   
+   if ((res = mp_init(&tmp)) != MP_OKAY) {
+      return res;
+   }
+   
+   p = mp_count_bits(a);
+   if ((res = mp_2expt(&tmp, p)) != MP_OKAY) {
+      mp_clear(&tmp);
+      return res;
+   }
+   
+   if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) {
+      mp_clear(&tmp);
+      return res;
+   }
+   
+   *d = tmp.dp[0];
+   mp_clear(&tmp);
+   return MP_OKAY;
+}
+
+/* End: bn_mp_reduce_2k_setup.c */
+
+/* Start: bn_mp_reduce_is_2k.c */
+#line 0 "bn_mp_reduce_is_2k.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* determines if mp_reduce_2k can be used */
+int 
+mp_reduce_is_2k(mp_int *a)
+{
+   int ix, iy;
+   
+   if (a->used == 0) {
+      return 0;
+   } else if (a->used == 1) {
+      return 1;
+   } else if (a->used > 1) {
+      iy = mp_count_bits(a);
+      for (ix = DIGIT_BIT; ix < iy; ix++) {
+          if ((a->dp[ix/DIGIT_BIT] & ((mp_digit)1 << (mp_digit)(ix % DIGIT_BIT))) == 0) {
+             return 0;
+          }
+      }
+   }
+   return 1;
+}
+
+
+/* End: bn_mp_reduce_is_2k.c */
+
+/* Start: bn_mp_reduce_setup.c */
+#line 0 "bn_mp_reduce_setup.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* pre-calculate the value required for Barrett reduction
+ * For a given modulus "b" it calulates the value required in "a"
+ */
+int
+mp_reduce_setup (mp_int * a, mp_int * b)
+{
+  int     res;
+  
+  if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) {
+    return res;
+  }
+  return mp_div (a, b, a, NULL);
+}
+
+/* End: bn_mp_reduce_setup.c */
+
 /* Start: bn_mp_rshd.c */
 #line 0 "bn_mp_rshd.c"
 /* LibTomMath, multiple-precision integer library -- Tom St Denis
@@ -5012,15 +5050,15 @@ mp_rshd (mp_int * a, int b)
   }
 
   {
-    register mp_digit *tmpa, *tmpaa;
+    register mp_digit *bottom, *top;
 
     /* shift the digits down */
 
-    /* base */
-    tmpa = a->dp;
+    /* bottom */
+    bottom = a->dp;
 
-    /* offset into digits */
-    tmpaa = a->dp + b;
+    /* top [offset into digits] */
+    top = a->dp + b;
 
     /* this is implemented as a sliding window where 
      * the window is b-digits long and digits from 
@@ -5033,15 +5071,17 @@ mp_rshd (mp_int * a, int b)
                   \-------------------/      ---->
      */
     for (x = 0; x < (a->used - b); x++) {
-      *tmpa++ = *tmpaa++;
+      *bottom++ = *top++;
     }
 
     /* zero the top digits */
     for (; x < a->used; x++) {
-      *tmpa++ = 0;
+      *bottom++ = 0;
     }
   }
-  mp_clamp (a);
+  
+  /* remove excess digits */
+  a->used -= b;
 }
 
 /* End: bn_mp_rshd.c */
@@ -5114,7 +5154,7 @@ mp_set_int (mp_int * a, unsigned int b)
     b <<= 4;
 
     /* ensure that digits are not clamped off */
-    a->used += 32 / DIGIT_BIT + 2;
+    a->used += 1;
   }
   mp_clamp (a);
   return MP_OKAY;
@@ -5205,12 +5245,16 @@ int
 mp_sqr (mp_int * a, mp_int * b)
 {
   int     res;
-  if (a->used > KARATSUBA_SQR_CUTOFF) {
+  if (a->used >= TOOM_SQR_CUTOFF) {
+    res = mp_toom_sqr(a, b);
+  } else if (a->used >= KARATSUBA_SQR_CUTOFF) {
     res = mp_karatsuba_sqr (a, b);
   } else {
 
     /* can we use the fast multiplier? */
-    if ((a->used * 2 + 1) < 512 && a->used < (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) {
+    if ((a->used * 2 + 1) < MP_WARRAY && 
+         a->used < 
+         (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) {
       res = fast_s_mp_sqr (a, b);
     } else {
       res = s_mp_sqr (a, b);
@@ -5481,8 +5525,8 @@ mp_to_unsigned_bin (mp_int * a, unsigned char *b)
 
 /* End: bn_mp_to_unsigned_bin.c */
 
-/* Start: bn_mp_unsigned_bin_size.c */
-#line 0 "bn_mp_unsigned_bin_size.c"
+/* Start: bn_mp_toom_mul.c */
+#line 0 "bn_mp_toom_mul.c"
 /* LibTomMath, multiple-precision integer library -- Tom St Denis
  *
  * LibTomMath is library that provides for multiple-precision
@@ -5499,63 +5543,561 @@ mp_to_unsigned_bin (mp_int * a, unsigned char *b)
  */
 #include <tommath.h>
 
-/* get the size for an unsigned equivalent */
-int
-mp_unsigned_bin_size (mp_int * a)
+/* multiplication using Toom-Cook 3-way algorithm */
+int 
+mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
 {
-  int     size = mp_count_bits (a);
-  return (size / 8 + ((size & 7) != 0 ? 1 : 0));
-}
+    mp_int w0, w1, w2, w3, w4, tmp1, tmp2, a0, a1, a2, b0, b1, b2;
+    int res, B;
+        
+    /* init temps */
+    if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &b0, &b1, &b2, &tmp1, &tmp2, NULL)) != MP_OKAY) {
+       return res;
+    }
+    
+    /* B */
+    B = MIN(a->used, b->used) / 3;
+    
+    /* a = a2 * B^2 + a1 * B + a0 */
+    if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) {
+       goto ERR;
+    }
 
-/* End: bn_mp_unsigned_bin_size.c */
+    if ((res = mp_copy(a, &a1)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a1, B);
+    mp_mod_2d(&a1, DIGIT_BIT * B, &a1);
 
-/* Start: bn_mp_xor.c */
-#line 0 "bn_mp_xor.c"
-/* LibTomMath, multiple-precision integer library -- Tom St Denis
- *
- * LibTomMath is library that provides for multiple-precision
- * integer arithmetic as well as number theoretic functionality.
- *
- * The library is designed directly after the MPI library by
- * Michael Fromberger but has been written from scratch with
- * additional optimizations in place.
- *
- * The library is free for all purposes without any express
- * guarantee it works.
- *
- * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
- */
-#include <tommath.h>
+    if ((res = mp_copy(a, &a2)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a2, B*2);
+    
+    /* b = b2 * B^2 + b1 * B + b0 */
+    if ((res = mp_mod_2d(b, DIGIT_BIT * B, &b0)) != MP_OKAY) {
+       goto ERR;
+    }
 
-/* XOR two ints together */
-int
-mp_xor (mp_int * a, mp_int * b, mp_int * c)
-{
-  int     res, ix, px;
-  mp_int  t, *x;
+    if ((res = mp_copy(b, &b1)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&b1, B);
+    mp_mod_2d(&b1, DIGIT_BIT * B, &b1);
 
-  if (a->used > b->used) {
-    if ((res = mp_init_copy (&t, a)) != MP_OKAY) {
-      return res;
+    if ((res = mp_copy(b, &b2)) != MP_OKAY) {
+       goto ERR;
     }
-    px = b->used;
-    x = b;
-  } else {
-    if ((res = mp_init_copy (&t, b)) != MP_OKAY) {
-      return res;
+    mp_rshd(&b2, B*2);
+    
+    /* w0 = a0*b0 */
+    if ((res = mp_mul(&a0, &b0, &w0)) != MP_OKAY) {
+       goto ERR;
     }
-    px = a->used;
-    x = a;
-  }
+    
+    /* w4 = a2 * b2 */
+    if ((res = mp_mul(&a2, &b2, &w4)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w1 = (a2 + 2(a1 + 2a0))(b2 + 2(b1 + 2b0)) */
+    if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul_2(&b0, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul(&tmp1, &tmp2, &w1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w3 = (a0 + 2(a1 + 2a2))(b0 + 2(b1 + 2b2)) */
+    if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul_2(&b2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_mul(&tmp1, &tmp2, &w3)) != MP_OKAY) {
+       goto ERR;
+    }
+    
 
-  for (ix = 0; ix < px; ix++) {
-    t.dp[ix] ^= x->dp[ix];
-  }
-  mp_clamp (&t);
-  mp_exch (c, &t);
-  mp_clear (&t);
-  return MP_OKAY;
-}
+    /* w2 = (a2 + a1 + a0)(b2 + b1 + b0) */
+    if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&b2, &b1, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul(&tmp1, &tmp2, &w2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* now solve the matrix 
+    
+       0  0  0  0  1
+       1  2  4  8  16
+       1  1  1  1  1
+       16 8  4  2  1
+       1  0  0  0  0
+       
+       using 12 subtractions, 4 shifts, 2 small divisions and 1 small multiplication 
+     */
+     
+     /* r1 - r4 */
+     if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r0 */
+     if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/2 */
+     if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/2 */
+     if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r2 - r0 - r4 */
+     if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - 8r0 */
+     if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - 8r4 */
+     if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* 3r2 - r1 - r3 */
+     if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/3 */
+     if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/3 */
+     if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     
+     /* at this point shift W[n] by B*n */
+     if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+     if ((res = mp_add(&w0, &w1, c)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&tmp1, c, c)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+ERR:
+     mp_clear_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &b0, &b1, &b2, &tmp1, &tmp2, NULL);
+     return res;
+}     
+     
+
+/* End: bn_mp_toom_mul.c */
+
+/* Start: bn_mp_toom_sqr.c */
+#line 0 "bn_mp_toom_sqr.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* squaring using Toom-Cook 3-way algorithm */
+int 
+mp_toom_sqr(mp_int *a, mp_int *b)
+{
+    mp_int w0, w1, w2, w3, w4, tmp1, a0, a1, a2;
+    int res, B;
+        
+    /* init temps */
+    if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL)) != MP_OKAY) {
+       return res;
+    }
+
+    /* B */
+    B = a->used / 3;
+    
+    /* a = a2 * B^2 + a1 * B + a0 */
+    if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) {
+       goto ERR;
+    }
+
+    if ((res = mp_copy(a, &a1)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a1, B);
+    mp_mod_2d(&a1, DIGIT_BIT * B, &a1);
+
+    if ((res = mp_copy(a, &a2)) != MP_OKAY) {
+       goto ERR;
+    }
+    mp_rshd(&a2, B*2);
+        
+    /* w0 = a0*a0 */
+    if ((res = mp_sqr(&a0, &w0)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w4 = a2 * a2 */
+    if ((res = mp_sqr(&a2, &w4)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w1 = (a2 + 2(a1 + 2a0))**2 */
+    if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_sqr(&tmp1, &w1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* w3 = (a0 + 2(a1 + 2a2))**2 */
+    if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    if ((res = mp_sqr(&tmp1, &w3)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+
+    /* w2 = (a2 + a1 + a0)**2 */
+    if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
+       goto ERR;
+    }
+    if ((res = mp_sqr(&tmp1, &w2)) != MP_OKAY) {
+       goto ERR;
+    }
+    
+    /* now solve the matrix 
+    
+       0  0  0  0  1
+       1  2  4  8  16
+       1  1  1  1  1
+       16 8  4  2  1
+       1  0  0  0  0
+       
+       using 12 subtractions, 4 shifts, 2 small divisions and 1 small multiplication.
+     */
+     
+     /* r1 - r4 */
+     if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r0 */
+     if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/2 */
+     if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/2 */
+     if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r2 - r0 - r4 */
+     if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - 8r0 */
+     if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - 8r4 */
+     if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* 3r2 - r1 - r3 */
+     if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1 - r2 */
+     if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3 - r2 */
+     if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r1/3 */
+     if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     /* r3/3 */
+     if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) {
+        goto ERR;
+     }
+     
+     /* at this point shift W[n] by B*n */
+     if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+     if ((res = mp_add(&w0, &w1, b)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) {
+        goto ERR;
+     }
+     if ((res = mp_add(&tmp1, b, b)) != MP_OKAY) {
+        goto ERR;
+     }     
+     
+ERR:
+     mp_clear_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL);
+     return res;
+}     
+     
+
+/* End: bn_mp_toom_sqr.c */
+
+/* Start: bn_mp_unsigned_bin_size.c */
+#line 0 "bn_mp_unsigned_bin_size.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* get the size for an unsigned equivalent */
+int
+mp_unsigned_bin_size (mp_int * a)
+{
+  int     size = mp_count_bits (a);
+  return (size / 8 + ((size & 7) != 0 ? 1 : 0));
+}
+
+/* End: bn_mp_unsigned_bin_size.c */
+
+/* Start: bn_mp_xor.c */
+#line 0 "bn_mp_xor.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* XOR two ints together */
+int
+mp_xor (mp_int * a, mp_int * b, mp_int * c)
+{
+  int     res, ix, px;
+  mp_int  t, *x;
+
+  if (a->used > b->used) {
+    if ((res = mp_init_copy (&t, a)) != MP_OKAY) {
+      return res;
+    }
+    px = b->used;
+    x = b;
+  } else {
+    if ((res = mp_init_copy (&t, b)) != MP_OKAY) {
+      return res;
+    }
+    px = a->used;
+    x = a;
+  }
+
+  for (ix = 0; ix < px; ix++) {
+    t.dp[ix] ^= x->dp[ix];
+  }
+  mp_clamp (&t);
+  mp_exch (c, &t);
+  mp_clear (&t);
+  return MP_OKAY;
+}
 
 /* End: bn_mp_xor.c */
 
@@ -5954,7 +6496,6 @@ s_mp_add (mp_int * a, mp_int * b, mp_int * c)
   olduse = c->used;
   c->used = max + 1;
 
-  /* set the carry to zero */
   {
     register mp_digit u, *tmpa, *tmpb, *tmpc;
     register int i;
@@ -6014,6 +6555,222 @@ s_mp_add (mp_int * a, mp_int * b, mp_int * c)
 
 /* End: bn_s_mp_add.c */
 
+/* Start: bn_s_mp_exptmod.c */
+#line 0 "bn_s_mp_exptmod.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+int
+s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
+{
+  mp_int  M[256], res, mu;
+  mp_digit buf;
+  int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
+
+  /* find window size */
+  x = mp_count_bits (X);
+  if (x <= 7) {
+    winsize = 2;
+  } else if (x <= 36) {
+    winsize = 3;
+  } else if (x <= 140) {
+    winsize = 4;
+  } else if (x <= 450) {
+    winsize = 5;
+  } else if (x <= 1303) {
+    winsize = 6;
+  } else if (x <= 3529) {
+    winsize = 7;
+  } else {
+    winsize = 8;
+  }
+
+#ifdef MP_LOW_MEM
+    if (winsize > 5) {
+       winsize = 5;
+    }
+#endif
+
+  /* init M array */
+  for (x = 0; x < (1 << winsize); x++) {
+    if ((err = mp_init_size (&M[x], 1)) != MP_OKAY) {
+      for (y = 0; y < x; y++) {
+        mp_clear (&M[y]);
+      }
+      return err;
+    }
+  }
+
+  /* create mu, used for Barrett reduction */
+  if ((err = mp_init (&mu)) != MP_OKAY) {
+    goto __M;
+  }
+  if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) {
+    goto __MU;
+  }
+
+  /* create M table
+   *
+   * The M table contains powers of the input base, e.g. M[x] = G**x mod P
+   *
+   * The first half of the table is not computed though accept for M[0] and M[1]
+   */
+  if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) {
+    goto __MU;
+  }
+
+  /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) times */
+  if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) {
+    goto __MU;
+  }
+
+  for (x = 0; x < (winsize - 1); x++) {
+    if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != MP_OKAY) {
+      goto __MU;
+    }
+    if ((err = mp_reduce (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) {
+      goto __MU;
+    }
+  }
+
+  /* create upper table */
+  for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) {
+    if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) {
+      goto __MU;
+    }
+    if ((err = mp_reduce (&M[x], P, &mu)) != MP_OKAY) {
+      goto __MU;
+    }
+  }
+
+  /* setup result */
+  if ((err = mp_init (&res)) != MP_OKAY) {
+    goto __MU;
+  }
+  mp_set (&res, 1);
+
+  /* set initial mode and bit cnt */
+  mode   = 0;
+  bitcnt = 1;
+  buf    = 0;
+  digidx = X->used - 1;
+  bitcpy = 0;
+  bitbuf = 0;
+
+  for (;;) {
+    /* grab next digit as required */
+    if (--bitcnt == 0) {
+      if (digidx == -1) {
+        break;
+      }
+      buf = X->dp[digidx--];
+      bitcnt = (int) DIGIT_BIT;
+    }
+
+    /* grab the next msb from the exponent */
+    y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
+    buf <<= (mp_digit)1;
+
+    /* if the bit is zero and mode == 0 then we ignore it
+     * These represent the leading zero bits before the first 1 bit
+     * in the exponent.  Technically this opt is not required but it
+     * does lower the # of trivial squaring/reductions used
+     */
+    if (mode == 0 && y == 0)
+      continue;
+
+    /* if the bit is zero and mode == 1 then we square */
+    if (mode == 1 && y == 0) {
+      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
+        goto __RES;
+      }
+      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+        goto __RES;
+      }
+      continue;
+    }
+
+    /* else we add it to the window */
+    bitbuf |= (y << (winsize - ++bitcpy));
+    mode = 2;
+
+    if (bitcpy == winsize) {
+      /* ok window is filled so square as required and multiply  */
+      /* square first */
+      for (x = 0; x < winsize; x++) {
+        if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
+          goto __RES;
+        }
+        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+          goto __RES;
+        }
+      }
+
+      /* then multiply */
+      if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) {
+        goto __MU;
+      }
+      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+        goto __MU;
+      }
+
+      /* empty window and reset */
+      bitcpy = 0;
+      bitbuf = 0;
+      mode = 1;
+    }
+  }
+
+  /* if bits remain then square/multiply */
+  if (mode == 2 && bitcpy > 0) {
+    /* square then multiply if the bit is set */
+    for (x = 0; x < bitcpy; x++) {
+      if ((err = mp_sqr (&res, &res)) != MP_OKAY) {
+        goto __RES;
+      }
+      if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+        goto __RES;
+      }
+
+      bitbuf <<= 1;
+      if ((bitbuf & (1 << winsize)) != 0) {
+        /* then multiply */
+        if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) {
+          goto __RES;
+        }
+        if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) {
+          goto __RES;
+        }
+      }
+    }
+  }
+
+  mp_exch (&res, Y);
+  err = MP_OKAY;
+__RES:mp_clear (&res);
+__MU:mp_clear (&mu);
+__M:
+  for (x = 0; x < (1 << winsize); x++) {
+    mp_clear (&M[x]);
+  }
+  return err;
+}
+
+/* End: bn_s_mp_exptmod.c */
+
 /* Start: bn_s_mp_mul_digs.c */
 #line 0 "bn_s_mp_mul_digs.c"
 /* LibTomMath, multiple-precision integer library -- Tom St Denis
@@ -6205,8 +6962,8 @@ s_mp_sqr (mp_int * a, mp_int * b)
 {
   mp_int  t;
   int     res, ix, iy, pa;
-  mp_word r, u;
-  mp_digit tmpx, *tmpt;
+  mp_word r;
+  mp_digit u, tmpx, *tmpt;
 
   pa = a->used;
   if ((res = mp_init_size (&t, pa + pa + 1)) != MP_OKAY) {
@@ -6217,7 +6974,8 @@ s_mp_sqr (mp_int * a, mp_int * b)
   for (ix = 0; ix < pa; ix++) {
     /* first calculate the digit at 2*ix */
     /* calculate double precision result */
-    r = ((mp_word) t.dp[ix + ix]) + ((mp_word) a->dp[ix]) * ((mp_word) a->dp[ix]);
+    r = ((mp_word) t.dp[ix + ix]) + 
+        ((mp_word) a->dp[ix]) * ((mp_word) a->dp[ix]);
 
     /* store lower part in result */
     t.dp[ix + ix] = (mp_digit) (r & ((mp_word) MP_MASK));
@@ -6229,7 +6987,8 @@ s_mp_sqr (mp_int * a, mp_int * b)
     tmpx = a->dp[ix];
 
     /* alias for where to store the results */
-    tmpt = &(t.dp[ix + ix + 1]);
+    tmpt = t.dp + (ix + ix + 1);
+    
     for (iy = ix + 1; iy < pa; iy++) {
       /* first calculate the product */
       r = ((mp_word) tmpx) * ((mp_word) a->dp[iy]);
@@ -6245,13 +7004,9 @@ s_mp_sqr (mp_int * a, mp_int * b)
       /* get carry */
       u = (r >> ((mp_word) DIGIT_BIT));
     }
-    r = ((mp_word) * tmpt) + u;
-    *tmpt = (mp_digit) (r & ((mp_word) MP_MASK));
-    u = (r >> ((mp_word) DIGIT_BIT));
     /* propagate upwards */
-    ++tmpt;
-    while (u != ((mp_word) 0)) {
-      r = ((mp_word) * tmpt) + ((mp_word) 1);
+    while (u != ((mp_digit) 0)) {
+      r = ((mp_word) * tmpt) + ((mp_word) u);
       *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
       u = (r >> ((mp_word) DIGIT_BIT));
     }
@@ -6302,7 +7057,6 @@ s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
   olduse = c->used;
   c->used = max;
 
-  /* sub digits from lower part */
   {
     register mp_digit u, *tmpa, *tmpb, *tmpc;
     register int i;
@@ -6321,7 +7075,7 @@ s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
       /* U = carry bit of T[i]
        * Note this saves performing an AND operation since
        * if a carry does occur it will propagate all the way to the
-       * MSB.  As a result a single shift is required to get the carry
+       * MSB.  As a result a single shift is enough to get the carry
        */
       u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
 
@@ -6351,6 +7105,44 @@ s_mp_sub (mp_int * a, mp_int * b, mp_int * c)
   return MP_OKAY;
 }
 
+
 /* End: bn_s_mp_sub.c */
 
-/* EOF */
+/* Start: bncore.c */
+#line 0 "bncore.c"
+/* LibTomMath, multiple-precision integer library -- Tom St Denis
+ *
+ * LibTomMath is library that provides for multiple-precision
+ * integer arithmetic as well as number theoretic functionality.
+ *
+ * The library is designed directly after the MPI library by
+ * Michael Fromberger but has been written from scratch with
+ * additional optimizations in place.
+ *
+ * The library is free for all purposes without any express
+ * guarantee it works.
+ *
+ * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org
+ */
+#include <tommath.h>
+
+/* Known optimal configurations
+
+ CPU                    /Compiler     /MUL CUTOFF/SQR CUTOFF
+-------------------------------------------------------------
+ Intel P4               /GCC v3.2     /        70/       108
+ AMD Athlon XP          /GCC v3.2     /       109/       127
+
+*/
+
+/* configured for a AMD XP Thoroughbred core with etc/tune.c */
+int     KARATSUBA_MUL_CUTOFF = 109,      /* Min. number of digits before Karatsuba multiplication is used. */
+        KARATSUBA_SQR_CUTOFF = 127,      /* Min. number of digits before Karatsuba squaring is used. */
+        
+        TOOM_MUL_CUTOFF      = 350,      /* no optimal values of these are known yet so set em high */
+        TOOM_SQR_CUTOFF      = 400; 
+
+/* End: bncore.c */
+
+
+/* EOF */
diff --git a/tommath.h b/tommath.h
index 0d56f02..8e43f6c 100644
--- a/tommath.h
+++ b/tommath.h
@@ -69,7 +69,7 @@ extern "C" {
    
    /* this is to make porting into LibTomCrypt easier :-) */
 #ifndef CRYPT
-   #ifdef _MSC_VER
+   #if defined(_MSC_VER) || defined(__BORLANDC__) 
       typedef unsigned __int64   ulong64;
       typedef signed __int64     long64;
    #else
@@ -81,7 +81,11 @@ extern "C" {
    typedef unsigned long      mp_digit;
    typedef ulong64            mp_word;
 
+#ifdef MP_31BIT   
+   #define DIGIT_BIT          31
+#else
    #define DIGIT_BIT          28
+#endif   
 #endif
 
 /* otherwise the bits per digit is calculated automatically from the size of a mp_digit */
@@ -112,7 +116,8 @@ typedef int           mp_err;
 /* you'll have to tune these... */
 extern int KARATSUBA_MUL_CUTOFF,
            KARATSUBA_SQR_CUTOFF,
-           MONTGOMERY_EXPT_CUTOFF;
+           TOOM_MUL_CUTOFF,
+           TOOM_SQR_CUTOFF;
 
 /* various build options */
 #define MP_PREC                 64      /* default digits of precision (must be power of two) */
@@ -270,6 +275,9 @@ int mp_mul_d(mp_int *a, mp_digit b, mp_int *c);
 /* a/b => cb + d == a */
 int mp_div_d(mp_int *a, mp_digit b, mp_int *c, mp_digit *d);
 
+/* a/3 => 3c + d == a */
+int mp_div_3(mp_int *a, mp_int *c, mp_digit *d);
+
 /* c = a**b */
 int mp_expt_d(mp_int *a, mp_digit b, mp_int *c);
 
@@ -341,6 +349,15 @@ void mp_dr_setup(mp_int *a, mp_digit *d);
 /* reduces a modulo b using the Diminished Radix method */
 int mp_dr_reduce(mp_int *a, mp_int *b, mp_digit mp);
 
+/* returns true if a can be reduced with mp_reduce_2k */
+int mp_reduce_is_2k(mp_int *a);
+
+/* determines k value for 2k reduction */
+int mp_reduce_2k_setup(mp_int *a, mp_digit *d);
+
+/* reduces a modulo b where b is of the form 2**p - k [0 <= a] */
+int mp_reduce_2k(mp_int *a, mp_int *n, mp_digit k);
+
 /* d = a**b (mod c) */
 int mp_exptmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
 
@@ -425,10 +442,13 @@ int s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
 int fast_s_mp_sqr(mp_int *a, mp_int *b);
 int s_mp_sqr(mp_int *a, mp_int *b);
 int mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c);
+int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c);
 int mp_karatsuba_sqr(mp_int *a, mp_int *b);
+int mp_toom_sqr(mp_int *a, mp_int *b);
 int fast_mp_invmod(mp_int *a, mp_int *b, mp_int *c);
 int fast_mp_montgomery_reduce(mp_int *a, mp_int *m, mp_digit mp);
 int mp_exptmod_fast(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int mode);
+int s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y);
 void bn_reverse(unsigned char *s, int len);
 
 #ifdef __cplusplus
diff --git a/tommath.src b/tommath.src
index f04f324..1dfb091 100644
--- a/tommath.src
+++ b/tommath.src
@@ -59,16 +59,16 @@ Algonquin College \\
 Mads Rasmussen \\
 Open Communications Security \\
 \\
-Gregory Rose \\
-Qualcomm \\
+Greg Rose \\
+QUALCOMM Australia \\
 \end{tabular}
 %\end{small}
 }
 }
 \maketitle
-This text in its entirety is copyrighted \copyright{}2003 by Tom St Denis.  It may not be redistributed 
-electronically or otherwise without the sole permission of the author.  The text is freely re distributable as long as
-it is packaged along with the LibTomMath project in a non-commercial project.  Contact the
+This text in its entirety is copyright \copyright{}2003 by Tom St Denis.  It may not be redistributed 
+electronically or otherwise without the sole permission of the author.  The text is freely redistributable as long as
+it is packaged along with the LibTomMath library in a non-commercial project.  Contact the
 author for other redistribution rights.
 
 This text corresponds to the v0.17 release of the LibTomMath project.
@@ -105,13 +105,13 @@ single-precision data types which are incapable of precisely representing intege
 For example, consider multiplying $1,234,567$ by $9,876,543$ in C with an ``unsigned long'' data type.  With an 
 x86 machine the result is $4,136,875,833$ while the true result is $12,193,254,061,881$.  The original inputs 
 were approximately $21$ and $24$ bits respectively.  If the C language cannot multiply two relatively small values 
-together precisely how does anyone expect it to multiply two values which are considerably larger?
+together precisely how does anyone expect it to multiply two values that are considerably larger?
 
-Most advancements in fast multiple precision arithmetic stems from the desire for faster cryptographic primitives.  However, cryptography
-is not the only field of study that can benefit fast large integer routines.  Another auxiliary use for multiple precision integers is 
+Most advancements in fast multiple precision arithmetic stem from the desire for faster cryptographic primitives.  However, cryptography
+is not the only field of study that can benefit from fast large integer routines.  Another auxiliary use for multiple precision integers is 
 high precision floating point data types.  The basic IEEE standard floating point type is made up of an integer mantissa $q$ and an exponent $e$.  
-Numbers are given in the form $n = q \cdot b^e$ where $b = 2$ is convention.  Since IEEE is meant to be implemented in 
-hardware the precision of the mantissa is often fairly small (\textit{roughly 23 bits}).  Since the mantissa is merely an 
+Numbers are given in the form $n = q \cdot b^e$ where $b = 2$ is specified.  Since IEEE is meant to be implemented in 
+hardware the precision of the mantissa is often fairly small (\textit{23, 48 and 64 bits}).  Since the mantissa is merely an 
 integer a large multiple precision integer could be used.  In effect very high precision floating point arithmetic 
 could be performed.  This would be useful where scientific applications must minimize the total output error over long simulations.  
 
@@ -122,15 +122,15 @@ the C and Java programming languages.  In essence multiple precision arithmetic 
 performed on members of an algebraic group whose precision is not fixed.  The algorithms when implemented to be multiple
 precision can allow a developer to work with any practical precision required.
 
-Typically the arithmetic is performed over the ring of integers denoted by a $\Z$ and referred to casually as ``bignum'' 
-routines.  However, it is possible to have rings of polynomials as well typically denoted by $\Z/p\Z \left [ X \right ]$ 
-which could have variable precision (\textit{or degree}).  This text will discuss implementation of the former, however,
-implementing polynomial basis routines should be relatively easy after reading this text.
+Typically the arithmetic over the ring of integers denoted by $\Z$ is performed by routines that are collectively and 
+casually referred to as ``bignum'' routines.  However, it is possible to have rings of polynomials as well typically 
+denoted by $\Z/p\Z \left [ X \right ]$ which could have variable precision (\textit{or degree}).  This text will 
+discuss implementation of the former, however implementing polynomial basis routines should be relatively easy after reading this text.
 
 \subsection{Benefits of Multiple Precision Arithmetic}
 \index{precision} \index{accuracy}
-Precision is defined loosely as the proximity to the real value a given representation is.  Accuracy is defined as the 
-reproducibility of the result.  For example, the calculation $1/3 = 0.25$ is imprecise but can be accurate provided 
+Precision of the real value to a given precision is defined loosely as the proximity of the real value to a given representation.  
+Accuracy is defined as the reproducibility of the result.  For example, the calculation $1/3 = 0.25$ is imprecise but can be accurate provided 
 it is reproducible.
 
 The benefit of multiple precision representations over single precision representations is that 
@@ -144,12 +144,12 @@ modest computer resources.  The only reasonable case where a multiple precision 
 emulating a floating point data type.  However, with multiple precision integer arithmetic no precision is lost.
 
 \subsection{Basis of Operations}
-At the heart of all multiple precision integer operations are the ``long-hand'' algorithms we all learnt as children 
+At the heart of all multiple precision integer operations are the ``long-hand'' algorithms we all learned as children 
 in grade school.  For example, to multiply $1,234$ by $981$ the student is not taught to memorize the times table for 
-$1,234$ instead they are taught how to long-multiply.  That is to multiply each column using simple single digit 
-multiplications and add the resulting products by column.  The representation that most are familiar with is known as 
-decimal or formally as radix-10. A radix-$n$ representation simply means there are $n$ possible values per digit.  
-For example, binary would be a radix-2 representation.
+$1,234$, instead they are taught how to long-multiply.  That is to multiply each column using simple single digit 
+multiplications, line up the partial results, and add the resulting products by column.  The representation that most 
+are familiar with is known as decimal or formally as radix-10. A radix-$n$ representation simply means there are 
+$n$ possible values per digit.  For example, binary would be a radix-2 representation.
 
 In essence computer based multiple precision arithmetic is very much the same.  The most notable difference is the usage
 of a binary friendly radix.  That is to use a radix of the form $2^k$ where $k$ is typically the size of a machine 
@@ -159,22 +159,21 @@ squaring instead of traditional long-hand algorithms.
 \section{Purpose of This Text}
 The purpose of this text is to instruct the reader regarding how to implement multiple precision algorithms.  That is 
 to not only explain the core theoretical algorithms but also the various ``house keeping'' tasks that are neglected by
-authors of other texts on the subject.  Texts such as Knuths' ``The Art of Computer Programming, vol 2.'' and the 
-Handbook of Applied Cryptography (\textit{HAC}) give considerably detailed explanations of the theoretical aspects of 
-the algorithms and very little regarding the practical aspects.  
+authors of other texts on the subject.  Texts such as \cite[HAC]{HAC} and \cite{TAOCPV2} give considerably detailed 
+explanations of the theoretical aspects of the algorithms and very little regarding the practical aspects.  
 
-That is how an algorithm is explained and how it is actually implemented are two very different 
+How an algorithm is explained and how it is actually implemented are two very different 
 realities.  For example, algorithm 14.7 on page 594 of HAC lists a relatively simple algorithm for performing multiple 
 precision integer addition.  However, what the description lacks is any discussion concerning the fact that the two 
 integer inputs may be of differing magnitudes.  Similarly the division routine (\textit{Algorithm 14.20, pp. 598}) 
-does not discuss how to handle sign or handle the dividends decreasing magnitude in the main loop (\textit{Step \#3}).
+does not discuss how to handle sign or handle the dividend's decreasing magnitude in the main loop (\textit{Step \#3}).
 
 As well as the numerous practical oversights both of the texts do not discuss several key optimal algorithms required 
-such as ``Comba'' and Karatsuba multipliers and fast modular inversion.  These optimal algorithms are considerably
-vital to achieve any form of useful performance in non-trivial applications.  
+such as ``Comba'' and Karatsuba multipliers and fast modular inversion.  These optimal algorithms are vital to achieve 
+any form of useful performance in non-trivial applications.  
 
 To solve this problem the focus of this text is on the practical aspects of implementing the algorithms that 
-constitute a multiple precision integer package with light cursory discussions on the theoretical aspects.  As a case 
+constitute a multiple precision integer package with light discussions on the theoretical aspects.  As a case 
 study the ``LibTomMath''\footnote{Available freely at http://math.libtomcrypt.org} package is used to demonstrate 
 algorithms with implementations that have been field tested and work very well.
 
@@ -182,8 +181,8 @@ algorithms with implementations that have been field tested and work very well.
 \subsection{Notation}
 A multiple precision integer of $n$-digits shall be denoted as $x = (x_n ... x_1 x_0)_{ \beta }$ to be the 
 multiple precision notation for the integer $x \equiv \sum_{i=0}^{n} x_i\beta^i$.  The elements of the array $x$ are
-said to be the radix $\beta$ digits of the integer.  For example, $x = (15,0,7)_{\beta}$ would represent the 
-integer $15\cdot\beta^2 + 0\cdot\beta^1 + 7\cdot\beta^0$.  
+said to be the radix $\beta$ digits of the integer.  For example, $x = (1,2,3)_{10}$ would represent the 
+integer $1\cdot 10^2 + 2\cdot10^1 + 3\cdot10^0 = 123$.  
 
 A ``mp\_int'' shall refer to a composite structure which contains the digits of the integer as well as auxilary data
 required to manipulate the data.  These additional members are discussed in ~BASICOP~.  For the purposes of this text
@@ -198,6 +197,11 @@ will be stored in a double-precision arrays.  For the purposes of this text $x_j
 $j$'th digit of a single-precision array and $\hat x_j$ will refer to the $j$'th digit of a double-precision
 array.
 
+The $\lfloor \mbox{ } \rfloor$ brackets represent a value truncated and rounded down to the nearest integer.  The $\lceil \mbox{ } \rceil$ brackets 
+represent a value truncated and rounded up to the nearest integer.  Typically when the $/$ division symbol is used the intention is to perform an integer
+division.  For example, $5/2 = 2$ which will often be written as $\lfloor 5/2 \rfloor = 2$ for clarity.  When a value is presented as a fraction
+such as $5 \over 2$ a real value division is implied.
+
 \subsection{Work Effort}
 \index{big-O}
 To measure the efficiency of various algorithms a modified big-O notation is used.  In this system all 
@@ -218,7 +222,7 @@ off the most at the higher levels since they represent the bulk of the effort re
 
 \section{Exercises}
 Within the more advanced chapters a section will be set aside to give the reader some challenging exercises.  These exercises are not 
-designed to be prize winning problems yet instead to be thought provoking.  Wherever possible the problems are foreward minded stating 
+designed to be prize winning problems, but to be thought provoking.  Wherever possible the problems are forward minded stating 
 problems that will be answered in subsequent chapters.  The reader is encouraged to finish the exercises as they appear to get a 
 better understanding of the subject material.  
 
@@ -267,39 +271,38 @@ is encouraged to answer the follow-up problems and try to draw the relevence of 
 
 \chapter{Introduction to LibTomMath}
 
-\section{What is the LibTomMath?}
-LibTomMath is a free and open source multiple precision number theoretic library written in portable ISO C
-source code.  By portable it is meant that the library does not contain any code that is platform dependent or otherwise
-problematic to use on any given platform.  The library has been successfully tested under numerous operating systems 
-including Solaris, MacOS, Windows, Linux, PalmOS and on standalone hardware such as the Gameboy Advance.  The 
-library is designed to contain enough functionality to be able to develop number theoretic applications such as public 
-key cryptosystems.
+\section{What is LibTomMath?}
+LibTomMath is a free and open source multiple precision library written in portable ISO C source code.  By portable it is 
+meant that the library does not contain any code that is computer platform dependent or otherwise problematic to use on any 
+given platform.  The library has been successfully tested under numerous operating systems including Solaris, MacOS, Windows, 
+Linux, PalmOS and on standalone hardware such as the Gameboy Advance.  The library is designed to contain enough 
+functionality to be able to develop applications such as public key cryptosystems.
 
-\section{Goals of the LibTomMath}
+\section{Goals of LibTomMath}
 
 Even though the library is written entirely in portable ISO C considerable care has been taken to 
 optimize the algorithm implementations within the library.  Specifically the code has been written to work well with
-the GNU C Compiler (\textit{GCC}) on both x86 and ARMv4 processors.  Wherever possible optimal 
-algorithms (\textit{such as Karatsuba multiplication, sliding window exponentiation and Montgomery reduction.}) have 
+the GNU C Compiler (\textit{GCC}) on both x86 and ARMv4 processors.  Wherever possible highly efficient 
+algorithms (\textit{such as Karatsuba multiplication, sliding window exponentiation and Montgomery reduction}) have 
 been provided to make the library as efficient as possible.  Even with the optimal and sometimes specialized 
-algorithms that have been included the API has been kept as simple as possible.  Often generic place holder routines 
-will make use of specialized algorithms automatically without the developers attention.  One such example
-is the generic multiplication algorithm \textbf{mp\_mul()} which will automatically use Karatsuba multiplication if the 
-inputs are of a specific size.
+algorithms that have been included the Application Programing Interface (\textit{API}) has been kept as simple as possible.  
+Often generic place holder routines will make use of specialized algorithms automatically without the developer's
+attention.  One such example is the generic multiplication algorithm \textbf{mp\_mul()} which will automatically use 
+Karatsuba multiplication if the inputs are of a specific size.
 
 Making LibTomMath as efficient as possible is not the only goal of the LibTomMath project.  Ideally the library should 
 be source compatible with another popular library which makes it more attractive for developers to use.  In this case the
 MPI library was used as a API template for all the basic functions.
 
-The project is also meant to act as a learning tool for students.  The logic being that no easy to follow ``bignum'' 
+The project is also meant to act as a learning tool for students.  The logic being that no easy-to-follow ``bignum'' 
 library exists which can be used to teach computer science students how to perform fast and reliable multiple precision 
-arithmetic.  To this end the source code has been given quite a few comments and algorithm discussion points.  Often 
-where applicable routines have more comments than lines of code.
+arithmetic.  To this end the source code has been given quite a few comments and algorithm discussion points.  Often routines have 
+more comments than lines of code.
 
 \section{Choice of LibTomMath}
 LibTomMath was chosen as the case study of this text not only because the author of both projects is one and the same but
 for more worthy reasons.  Other libraries such as GMP, MPI, LIP and OpenSSL have multiple precision 
-integer arithmetic routines but would not be ideal for this text for numerous reasons as will be explained in the 
+integer arithmetic routines but would not be ideal for this text for reasons as will be explained in the 
 following sub-sections.
 
 \subsection{Code Base}
@@ -308,17 +311,16 @@ segments of code littered throughout the source.  This clean and uncluttered app
 developer can more readily ascertain the true intent of a given section of source code without trying to keep track of
 what conditional code will be used.
 
-The code base of LibTomMath is also exceptionally well organized.  Each function is in its own separate source code file 
+The code base of LibTomMath is also well organized.  Each function is in its own separate source code file 
 which allows the reader to find a given function very fast.  When compiled with GCC for the x86 processor the entire 
 library is a mere 87,760 bytes (\textit{$116,182$ bytes for ARMv4 processors}).  This includes every single function 
 LibTomMath provides from basic arithmetic to various number theoretic functions such as modular exponentiation, various 
 reduction algorithms and Jacobi symbol computation.  
 
-By comparison MPI which has fewer number theoretic functions than LibTomMath compiled with the same conditions is 
-45,429 bytes (\textit{$54,536$ for ARMv4}).  GMP which has rather large collection of functions with the default 
-configuration on an x86 Athlon is 2,950,688 bytes.  Note that while LibTomMath has fewer functions than GMP it has been
-been used as the sole basis for several public key cryptosystems without having to seek additional outside functions
-to supplement the library.
+By comparison MPI which has fewer functions than LibTomMath compiled with the same conditions is 45,429 bytes 
+(\textit{$54,536$ for ARMv4}).  GMP which has rather large collection of functions with the default configuration on an 
+x86 Athlon is 2,950,688 bytes.  Note that while LibTomMath has fewer functions than GMP it has been used as the sole basis 
+for several public key cryptosystems without having to seek additional outside functions to supplement the library.
 
 \subsection{API Simplicity}
 LibTomMath is designed after the MPI library and shares the API design.  Quite often programs that use MPI will build 
@@ -335,7 +337,7 @@ While LibTomMath is certainly not the fastest library (\textit{GMP often beats L
 feature a set of optimal algorithms for tasks ranging from modular reduction to squaring.  GMP and LIP also feature
 such optimizations while MPI only uses baseline algorithms with no optimizations.
 
-LibTomMath is almost always a magnitude faster than the MPI library at computationally expensive tasks such as modular
+LibTomMath is almost always an order of magnitude faster than the MPI library at computationally expensive tasks such as modular
 exponentiation.  In the grand scheme of ``bignum'' libraries LibTomMath is faster than the average library and usually  
 slower than the best libraries such as GMP and OpenSSL by a small factor.
 
@@ -356,14 +358,31 @@ reader is encouraged to download their own copy of the library to actually be ab
 \chapter{Getting Started}
 MARK,BASICOP
 \section{Library Basics}
-To get the ``ball rolling'' so to speak a primitive data type and a series of primitive algorithms must be established.  First a data
+To begin the design of a multiple precision integer library a primitive data type and a series of primitive algorithms must be established.  A data
 type that will hold the information required to maintain a multiple precision integer must be designed.  With this basic data type of a series
-of low level algorithms for initializing, clearing, growing and clamping integers can be developed to form the basis of the entire
-package of algorithms.
+of low level algorithms for initializing, clearing, growing and optimizing multiple precision integers can be developed to form the basis of 
+the entire library of algorithms.
+
+\section{What is a Multiple Precision Integer?}
+Recall that most programming languages (\textit{in particular C}) only have fixed precision data types that on their own cannot be used
+to represent values larger than their precision alone will allow. The purpose of multiple precision algorithms is to use these fixed precision
+data types to create multiple precision integers which may represent values that are much larger.  
+
+As a well known analogy, school children are taught how to form numbers larger than nine by prepending more radix ten digits.  In the decimal system
+the largest value is only $9$ since the digits may only have values from $0$ to $9$.  However, by concatenating digits together larger numbers 
+may be represented.  Computer based multiple precision arithmetic is essentially the same concept except with a different radix.
+
+What most people probably do not think about explicitly are the various other attributes that describe a multiple precision integer.  For example,
+the integer $154_{10}$ has two immediately obvious properties.  First, the integer is positive, that is the sign of this particular integer 
+is positive as oppose to negative.  Second, the integer has three digits in its representation.  There is an additional property that the integer 
+posesses that does not concern pencil-and-paper arithmetic.  The third property is how many digits are allowed for the integer.  
 
-\section{The mp\_int structure}
-First the data type for storing multiple precision integers must be designed.  This data type must be able to hold information to 
-maintain an array of digits, how many are actually used in the representation and the sign.  The ISO C standard does not provide for 
+The human analogy of this third property is ensuring there is enough space on the paper to right the integer.  Computers must maintain a
+strict control on memory usage with respect to the digits of a multiple precision integer.  These three properties make up what is known
+as a multiple precision integer or mp\_int for short.  
+
+\subsection{The mp\_int structure}
+The mp\_int structure is the ISO C based manifestation of what represents a multiple precision integer.  The ISO C standard does not provide for 
 any such data type but it does provide for making composite data types known as structures.  The following is the structure definition 
 used within LibTomMath.
 
@@ -375,15 +394,25 @@ typedef struct  {
 } mp_int;
 \end{verbatim}
 
-The \textbf{used} parameter denotes how many digits of the array \textbf{dp} are actually being used.  The array 
-\textbf{dp} holds the digits that represent the integer desired.  The \textbf{alloc} parameter denotes how 
+The mp\_int structure can be broken down as follows.
+
+\begin{enumerate}
+\item The \textbf{used} parameter denotes how many digits of the array \textbf{dp} contain the digits used to represent
+a given integer.  The \textbf{used} count must not exceed the \textbf{alloc} count.  
+
+\item The array \textbf{dp} holds the digits that represent the given integer.  It is padded with $\textbf{alloc} - \textbf{used}$ zero
+digits.
+
+\item The \textbf{alloc} parameter denotes how 
 many digits are available in the array to use by functions before it has to increase in size.  When the \textbf{used} count 
-of a result would exceed the \textbf{alloc} count all LibTomMath routines will automatically increase the size of the 
-array to accommodate the precision of the result.  The \textbf{sign} parameter denotes the sign as either zero/positive 
-(\textbf{MP\_ZPOS}) or negative (\textbf{MP\_NEG}).  
+of a result would exceed the \textbf{alloc} count all of the algorithms will automatically increase the size of the 
+array to accommodate the precision of the result.  
+
+\item The \textbf{sign} parameter denotes the sign as either zero/positive (\textbf{MP\_ZPOS}) or negative (\textbf{MP\_NEG}).  
+\end{enumerate}
 
 \section{Argument Passing}
-A convention of arugment passing must be adopted early on in the development of any library.  Making the function prototypes
+A convention of argument passing must be adopted early on in the development of any library.  Making the function prototypes
 consistent will help eliminate many headaches in the future as the library grows to significant complexity.  In LibTomMath the multiple precision 
 integer functions accept parameters from left to right as pointers to mp\_int structures.  That means that the source operands are 
 placed on the left and the destination on the right.   Consider the following examples.
@@ -398,17 +427,18 @@ The left to right order is a fairly natural way to implement the functions since
 functions and make sense of them.  For example, the first function would read ``multiply a and b and store in c''.
 
 Certain libraries (\textit{LIP by Lenstra for instance}) accept parameters the other way around.  That is the destination
-on the left and arguments on the right.  In truth it is entirely a matter of preference.  
+on the left and arguments on the right.  In truth it is entirely a matter of preference.  In the case of LibTomMath the 
+convention from the MPI library has been adopted.  
 
 Another very useful design consideration is whether to allow argument sources to also be a destination.  For example, the
 second example (\textit{mp\_add}) adds $a$ to $b$ and stores in $a$.  This is an important feature to implement since it
 allows the higher up functions to cut down on the number of variables.  However, to implement this feature specific
-care has to be given to ensure the destination is not written before the source is fully read.
+care has to be given to ensure the destination is not modified before the source is fully read.
 
 \section{Return Values}
 A well implemented library, no matter what its purpose, should trap as many runtime errors as possible and return them to the 
-caller.  By catching runtime errors a library can be guaranteed to prevent undefined behaviour within reason.  In a multiple precision 
-library the only errors that are bound to occur are related to inappropriate inputs (\textit{division by zero for instance}) or 
+caller.  By catching runtime errors a library can be guaranteed to prevent undefined behaviour.  In a multiple precision 
+library the only errors that can occur occur are related to inappropriate inputs (\textit{division by zero for instance}) or 
 memory allocation errors.
 
 In LibTomMath any function that can cause a runtime error will return an error as an \textbf{int} data type with one of the 
@@ -425,7 +455,7 @@ following values.
 \end{tabular}
 \end{center}
 
-When an error is detected within a function it should free any memory they allocated and return as soon as possible.  The goal
+When an error is detected within a function it should free any memory it allocated and return as soon as possible.  The goal
 is to leave the system in the same state the system was when the function was called.  Error checking with this style of API is fairly simple.
 
 \begin{verbatim}
@@ -437,7 +467,7 @@ is to leave the system in the same state the system was when the function was ca
 \end{verbatim}
 
 The GMP library uses C style \textit{signals} to flag errors which is of questionable use.  Not all errors are fatal 
-and it is not ideal to force developers to have signal handlers for such cases.
+and it was not deemed ideal by the author of LibTomMath to force developers to have signal handlers for such cases.
 
 \section{Initialization and Clearing}
 The logical starting point when actually writing multiple precision integer functions is the initialization and 
@@ -447,7 +477,7 @@ temporary integers are required.
 Given the basic mp\_int structure an initialization routine must first allocate memory to hold the digits of
 the integer.  Often it is optimal to allocate a sufficiently large pre-set number of digits even considering
 the initial integer will represent zero.  If only a single digit were allocated quite a few re-allocations
-would occur for the majority of inputs.  There exists a tradeoff between how many default digits to allocate
+would occur for the majority of inputs.  There is a tradeoff between how many default digits to allocate
 and how many re-allocations are tolerable.  
 
 If the memory for the digits has been successfully allocated then the rest of the members of the structure must
@@ -481,7 +511,7 @@ the memory required and initialize the integer to a default representation of ze
 
 \textbf{Algorithm mp\_init.}
 The \textbf{MP\_PREC} variable is a simple constant used to dictate minimal precision of allocated integers.  It is ideally at least equal to $32$ but 
-can be any reasonable power of two.  Step one and two allocate the memory and account for it.  If the allocation fails the algorithm returns
+can be any reasonable power of two.  Steps one and two allocate the memory and account for it.  If the allocation fails the algorithm returns
 immediately to signal the failure.  Step three will ensure that all the digits are in the default state of zero.  Finally steps 
 four through six set the default settings of the \textbf{sign}, \textbf{used} and \textbf{alloc} members of the mp\_int structure.
 
@@ -517,9 +547,9 @@ the mp\_clear algorithm.
 \textbf{Algorithm mp\_clear.}
 In steps one and two the memory for the digits are only free'd if they had not been previously released before.  
 This is more of concern for the implementation since it is used to prevent ``double-free'' errors.  It also helps catch
-code errors where mp\_ints are used after being cleared.  Simiarly steps three and four set the 
+code errors where mp\_ints are used after being cleared.  Similarly steps three and four set the 
 \textbf{used} and \textbf{alloc} to known values which would be easy to spot during debugging.  For example, if an mp\_int is expected
-to be non-zero and its \textbf{used} member observed to be zero (\textit{due to being cleared}) then an obvious bug in the code has been
+to be non-zero and its \textbf{used} member is observed to be zero (\textit{due to being cleared}) then an obvious bug in the code has been
 spotted.
 
 EXAM,bn_mp_clear.c
@@ -605,7 +635,7 @@ input size is known.
 \textbf{Algorithm mp\_init\_size.}
 The value of $v$ is calculated to be at least the requested amount of digits $b$ plus additional padding.  The padding is calculated
 to be at least \textbf{MP\_PREC} digits plus enough digits to make the digit count a multiple of \textbf{MP\_PREC}.  This padding is used to 
-prevent trivial allocations from becomming a bottleneck in the rest of the algorithms that depend on this.
+prevent trivial allocations from becoming a bottleneck in the rest of the algorithms that depend on this.
 
 EXAM,bn_mp_init_size.c
 
@@ -626,9 +656,9 @@ The mp\_init\_copy algorithm will perform this very task.
 \textbf{Input}.   An mp\_int $a$ and $b$\\
 \textbf{Output}.  $a$ is initialized to be a copy of $b$. \\
 \hline \\
-1.  Init $a$.  (\textit{hint: use mp\_init}) \\
+1.  Init $a$.  (\textit{mp\_init}) \\
 2.  If the init of $a$ was unsuccessful return(\textit{MP\_MEM}) \\
-3.  Copy $b$ to $a$.  (\textit{hint: use mp\_copy}) \\
+3.  Copy $b$ to $a$.  (\textit{mp\_copy}) \\
 4.  Return the status of the copy operation. \\
 \hline
 \end{tabular}
@@ -647,7 +677,7 @@ This will initialize \textbf{a} and make it a verbatim copy of the contents of \
 \textbf{a} will have its own memory allocated which means that \textbf{b} may be cleared after the call
 and \textbf{a} will be left intact.  
 
-\subsection{Multiple Integer Initializations}
+\subsection{Multiple Integer Initializations And Clearings}
 Occasionally a function will require a series of mp\_int data types to be made available.  The mp\_init\_multi algorithm
 is provided to simplify such cases.  The purpose of this algorithm is to initialize a variable length array of mp\_int 
 structures at once.  As a result algorithms that require multiple integers only has to use 
@@ -661,10 +691,10 @@ one algorithm to initialize all the mp\_int variables.
 \textbf{Output}.  The array is initialized such that each each mp\_int is ready to use. \\
 \hline \\
 1.  for $n$ from 0 to $k - 1$ do \\
-\hspace{+3mm}1.1.  Initialize the $n$'th mp\_int (\textit{hint: use mp\_init}) \\
+\hspace{+3mm}1.1.  Initialize the $n$'th mp\_int (\textit{mp\_init}) \\
 \hspace{+3mm}1.2.  If initialization failed then do \\
 \hspace{+6mm}1.2.1.  for $j$ from $0$ to $n$ do \\
-\hspace{+9mm}1.2.1.1.  Free the $j$'th mp\_int (\textit{hint: use mp\_clear}) \\
+\hspace{+9mm}1.2.1.1.  Free the $j$'th mp\_int (\textit{mp\_clear}) \\
 \hspace{+6mm}1.2.2.   Return(\textit{MP\_MEM}) \\
 2.  Return(\textit{MP\_OKAY}) \\
 \hline
@@ -678,10 +708,7 @@ The algorithm will initialize the array of mp\_int variables one at a time.  As 
 the previously initialized variables are cleared.  The goal is an ``all or nothing'' initialization which allows for quick recovery from runtime 
 errors.
 
-\subsection{Multiple Integer Clearing}
-Similarly to clear a variable length list of mp\_int structures the mp\_clear\_multi algorithm will be used.
-
-EXAM,bn_mp_multi.c
+Similarly to clear a variable length array of mp\_int structures the mp\_clear\_multi algorithm will be used.
 
 Consider the following snippet which demonstrates how to use both routines.
 \begin{small}
@@ -709,6 +736,13 @@ int main(void)
 \end{verbatim}
 \end{small}
 
+Note how both lists are terminated with the \textbf{NULL} variable.  This indicates to the algorithms to stop fetching parameters off
+of the stack.  If it is not present the functions will most likely cause a segmentation fault.  
+
+EXAM,bn_mp_multi.c
+
+Both routines are implemented in the same source file since they are typically used in conjunction with each other.  
+
 \section{Maintenance}
 A small useful collection of mp\_int maintenance functions will also prove useful.  
 
@@ -745,7 +779,7 @@ Step one will prevent a re-allocation from being performed if it was not require
 from growing excessively in code that erroneously calls mp\_grow.  Similar to mp\_init\_size the requested digit count
 is padded to provide more digits than requested.  
 
-In step four it is assumed that the reallocation leaves the lower $a.alloc$ digits intact.  Much akin to how the 
+In step four it is assumed that the reallocation leaves the lower $a.alloc$ digits intact.  This is much akin to how the 
 \textit{realloc} function from the standard C library works.  Since the newly allocated digits are assumed to contain
 undefined values they are also initially zeroed.
 
@@ -759,12 +793,12 @@ old \textbf{alloc} limit to make sure the integer is in a known state.
 \subsection{Clamping Excess Digits}
 When a function anticipates a result will be $n$ digits it is simpler to assume this is true within the body of 
 the function.  For example, a multiplication of a $i$ digit number by a $j$ digit produces a result of at most 
-$i + j + 1$ digits.  It is entirely possible that the result is $i + j$ though, with no final carry into the last 
-position.  However, suppose the destination had to be first expanded (\textit{via mp\_grow}) to accomodate $i + j$
+$i + j$ digits.  It is entirely possible that the result is $i + j - 1$ though, with no final carry into the last 
+position.  However, suppose the destination had to be first expanded (\textit{via mp\_grow}) to accomodate $i + j - 1$
 digits than further expanded to accomodate the final carry.  That would be a considerable waste of time since heap
 operations are relatively slow.
 
-The ideal solution is to always assume the result is $i + j + 1$ and fix up the \textbf{used} count after the function
+The ideal solution is to always assume the result is $i + j$ and fix up the \textbf{used} count after the function
 terminates.  This way a single heap operation (\textit{at most}) is required.  However, if the result was not checked
 there would be an excess high order zero digit.  
 
@@ -795,8 +829,8 @@ number which means that if the \textbf{used} count is decremented to zero the si
 \end{figure}
 
 \textbf{Algorithm mp\_clamp.}
-As can be expected this algorithm is very simple.  The loop on step one is indended to be iterate only once or twice at
-the most.  For example, for cases where there is not a carry to fill the last position.  Step two fixes the sign for 
+As can be expected this algorithm is very simple.  The loop on step one is expected to iterate only once or twice at
+the most.  For example, this will happen in cases where there is not a carry to fill the last position.  Step two fixes the sign for 
 when all of the digits are zero to ensure that the mp\_int is valid at all times.
 
 EXAM,bn_mp_clamp.c
@@ -825,7 +859,7 @@ $\left [ 1 \right ]$ & Give an example of when the algorithm  mp\_init\_copy mig
 
 \chapter{Basic Operations}
 \section{Copying an Integer}
-After the various house-keeping routines are in place, simpl algorithms can be designed to take advantage of them.  Being able
+After the various house-keeping routines are in place, simple algorithms can be designed to take advantage of them.  Being able
 to make a verbatim copy of an integer is a very useful function to have.  To copy an integer the mp\_copy algorithm will be used.
 
 \newpage\begin{figure}[here]
@@ -837,7 +871,7 @@ to make a verbatim copy of an integer is a very useful function to have.  To cop
 \hline \\
 1.  Check if $a$ and $b$ point to the same location in memory. \\
 2.  If true then return(\textit{MP\_OKAY}). \\
-3.  If $b.alloc < a.used$ then grow $b$ to $a.used$ digits.  (\textit{hint: use mp\_grow}) \\
+3.  If $b.alloc < a.used$ then grow $b$ to $a.used$ digits.  (\textit{mp\_grow}) \\
 4.  If failed to grow then return(\textit{MP\_MEM}). \\
 5.  for $n$ from 0 to $a.used - 1$ do \\
 \hspace{3mm}5.1  $b_{n} \leftarrow a_{n}$ \\
@@ -861,7 +895,7 @@ member of $a$ but a memory re-allocation is only required if the \textbf{alloc} 
 prevents trivial memory reallocations.
 
 Step 5 copies the digits from $a$ to $b$ while step 6 ensures that if initially $\vert b \vert > \vert a \vert$,
-the leading digits of $b$ will be zeroed.  Finally steps 7 and 8 copies the \textbf{used} and \textbf{sign} members over 
+the more significant digits of $b$ will be zeroed.  Finally steps 7 and 8 copies the \textbf{used} and \textbf{sign} members over 
 which completes the copy operation.
 
 EXAM,bn_mp_copy.c
@@ -871,7 +905,7 @@ make sure there is enough room.  If not enough space is available it returns the
 intact.
 
 The inner loop of the copy operation is contained between lines @34,{@ and @50,}@.  Many LibTomMath routines are designed with this source code style
-in mind, making aliases to shorten lengthy pointers (\textit{see line @38,->@ and @39,->@}) for rapid to use.  Also the
+in mind, making aliases to shorten lengthy pointers (\textit{see line @38,->@ and @39,->@}) for rapid use.  Also the
 use of nested braces creates a simple way to denote various portions of code that reside on various work levels.  Here, the copy loop is at the 
 $O(n)$ level.  
 
@@ -916,7 +950,7 @@ the absolute value of an mp\_int.
 \textbf{Input}.   An mp\_int $a$ \\
 \textbf{Output}.  Computes $b = \vert a \vert$ \\
 \hline \\
-1.  Copy $a$ to $b$.  (\textit{hint: use mp\_copy}) \\
+1.  Copy $a$ to $b$.  (\textit{mp\_copy}) \\
 2.  If the copy failed return(\textit{MP\_MEM}). \\
 3.  $b.sign \leftarrow MP\_ZPOS$ \\
 4.  Return(\textit{MP\_OKAY}) \\
@@ -942,7 +976,7 @@ the negative of an mp\_int input.
 \textbf{Input}.   An mp\_int $a$ \\
 \textbf{Output}.  Computes $b = -a$ \\
 \hline \\
-1.  Copy $a$ to $b$.  (\textit{hint: use mp\_copy}) \\
+1.  Copy $a$ to $b$.  (\textit{mp\_copy}) \\
 2.  If the copy failed return(\textit{MP\_MEM}). \\
 3.  If $a.sign = MP\_ZPOS$ then do \\
 \hspace{3mm}3.1  $b.sign = MP\_NEG$. \\
@@ -971,7 +1005,7 @@ Often a mp\_int must be set to a relatively small value such as $1$ or $2$.  For
 \textbf{Input}.   An mp\_int $a$ and a digit $b$ \\
 \textbf{Output}.  Make $a$ equivalent to $b$ \\
 \hline \\
-1.  Zero $a$ (\textit{hint: use mp\_zero}). \\
+1.  Zero $a$ (\textit{mp\_zero}). \\
 2.  $a_0 \leftarrow b \mbox{ (mod }\beta\mbox{)}$ \\
 3.  $a.used \leftarrow  \left \lbrace \begin{array}{ll}
                               1 &  \mbox{if }a_0 > 0 \\
@@ -989,16 +1023,14 @@ single digit is set (\textit{modulo $\beta$}) and the \textbf{used} count is adj
 
 EXAM,bn_mp_set.c
 
-Line @21,mp_zero@ calls mp\_zero() to clear the mp\_int and reset the sign.  Line @22,MP_MASK@ actually copies digit 
+Line @21,mp_zero@ calls mp\_zero() to clear the mp\_int and reset the sign.  Line @22,MP_MASK@ copies the digit 
 into the least significant location.  Note the usage of a new constant \textbf{MP\_MASK}.  This constant is used to quickly
-reduce an integer modulo $\beta$.  Since $\beta = 2^k$ it suffices to perform a binary AND with $MP\_MASK = 2^k - 1$ to perform
-the reduction.  Finally line @23,a->used@ will set the \textbf{used} member with respect to the digit actually set. This function 
-will always make the integer positive.
+reduce an integer modulo $\beta$.  Since $\beta$ is of the form $2^k$ for any suitable $k$ it suffices to perform a binary AND with 
+$MP\_MASK = 2^k - 1$ to perform the reduction.  Finally line @23,a->used@ will set the \textbf{used} member with respect to the 
+digit actually set. This function will always make the integer positive.
 
 One important limitation of this function is that it will only set one digit.  The size of a digit is not fixed, meaning source that uses 
-this function should take that into account.  The define \textbf{DIGIT\_BIT} in ``tommath.h'' 
-defines how many bits per digit are available.  Generally at least seven bits are guaranteed to be available per 
-digit.  This means that trivially small constants can be set using this function.
+this function should take that into account.  Meaning that only trivially small constants can be set using this function.
 
 \subsection{Setting Large Constants}
 To overcome the limitations of the mp\_set algorithm the mp\_set\_int algorithm is provided.  It accepts a ``long''
@@ -1011,13 +1043,13 @@ data type as input and will always treat it as a 32-bit integer.
 \textbf{Input}.   An mp\_int $a$ and a ``long'' integer $b$ \\
 \textbf{Output}.  Make $a$ equivalent to $b$ \\
 \hline \\
-1.  Zero $a$ (\textit{hint: use mp\_zero}) \\
+1.  Zero $a$ (\textit{mp\_zero}) \\
 2.  for $n$ from 0 to 7 do \\
-\hspace{3mm}2.1  $a \leftarrow a \cdot 16$ (\textit{hint: use mp\_mul2d}) \\
+\hspace{3mm}2.1  $a \leftarrow a \cdot 16$ (\textit{mp\_mul2d}) \\
 \hspace{3mm}2.2  $u \leftarrow \lfloor b / 2^{4(7 - n)} \rfloor \mbox{ (mod }16\mbox{)}$\\
 \hspace{3mm}2.3  $a_0 \leftarrow a_0 + u$ \\
-\hspace{3mm}2.4  $a.used \leftarrow a.used + \lfloor 32 / lg(\beta) \rfloor + 1$ \\
-3.  Clamp excess used digits (\textit{hint: use mp\_clamp}) \\
+\hspace{3mm}2.4  $a.used \leftarrow a.used + 1$ \\
+3.  Clamp excess used digits (\textit{mp\_clamp}) \\
 \hline
 \end{tabular}
 \end{center}
@@ -1026,9 +1058,9 @@ data type as input and will always treat it as a 32-bit integer.
 
 \textbf{Algorithm mp\_set\_int.}
 The algorithm performs eight iterations of a simple loop where in each iteration four bits from the source are added to the 
-mp\_int.  Step 2.1 will multiply the current result by sixteen making room for four more bits.  In step 2.2 the
-next four bits from the source are extracted.  The four bits are added to the mp\_int and the \textbf{used} digit count is 
-incremented.  The \textbf{used} digit counter is incremented since if any of the leading digits were zero the mp\_int would have
+mp\_int.  Step 2.1 will multiply the current result by sixteen making room for four more bits in the less significant positions.  In step 2.2 the
+next four bits from the source are extracted and are added to the mp\_int. The \textbf{used} digit count is 
+incremented to reflect the addition.  The \textbf{used} digit counter is incremented since if any of the leading digits were zero the mp\_int would have
 zero digits used and the newly added four bits would be ignored.
 
 Excess zero digits are trimmed in steps 2.1 and 3 by using higher level algorithms mp\_mul2d and mp\_clamp.
@@ -1093,20 +1125,20 @@ Obviously if the digit counts differ there would be an imaginary zero digit in t
 If both have the same number of digits than the actual digits themselves must be compared starting at the leading digit.  
 
 By step three both inputs must have the same number of digits so its safe to start from either $a.used - 1$ or $b.used - 1$ and count down to
-the zero'th digit.  If after all of the digits have been compared and no difference found the algorithm simply returns \textbf{MP\_EQ}.
+the zero'th digit.  If after all of the digits have been compared, no difference is found, the algorithm returns \textbf{MP\_EQ}.
 
 EXAM,bn_mp_cmp_mag.c
 
 The two if statements on lines @24,if@ and @28,if@ compare the number of digits in the two inputs.  These two are performed before all of the digits
 are compared since it is a very cheap test to perform and can potentially save considerable time.  The implementation given is also not valid 
-without those two statements.  $b.alloc$ may be smaller than $a.used$, meaning that undefined values will be read from $b$ passed the end of the 
+without those two statements.  $b.alloc$ may be smaller than $a.used$, meaning that undefined values will be read from $b$ past the end of the 
 array of digits.
 
 \subsection{Signed Comparisons}
 Comparing with sign considerations is also fairly critical in several routines (\textit{division for example}).  Based on an unsigned magnitude 
 comparison a trivial signed comparison algorithm can be written.
 
-\newpage\begin{figure}[here]
+\begin{figure}[here]
 \begin{center}
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_cmp}. \\
@@ -1116,7 +1148,7 @@ comparison a trivial signed comparison algorithm can be written.
 1.  if $a.sign = MP\_NEG$ and $b.sign = MP\_ZPOS$ then return(\textit{MP\_LT}) \\
 2.  if $a.sign = MP\_ZPOS$ and $b.sign = MP\_NEG$ then return(\textit{MP\_GT}) \\
 3.  if $a.sign = MP\_NEG$ then \\
-\hspace{+3mm}3.1  Return the unsigned comparison of $b$ and $a$ (\textit{hint: use mp\_cmp\_mag}) \\
+\hspace{+3mm}3.1  Return the unsigned comparison of $b$ and $a$ (\textit{mp\_cmp\_mag}) \\
 4   Otherwise \\
 \hspace{+3mm}4.1  Return the unsigned comparison of $a$ and $b$ \\
 \hline
@@ -1152,10 +1184,10 @@ $\left [ 1 \right ]$ & Suggest a simple method to speed up the implementation of
 
 \chapter{Basic Arithmetic}
 \section{Building Blocks}
-At this point algorithms for initialization, de-initialization, zeroing, copying, comparing and setting small constants have been 
-established.  The next logical set of algorithms to develop are the addition, subtraction and digit movement algorithms.  These 
-algorithms make use of the lower level algorithms and are the cruicial building block for the multipliers.  It is very important that these 
-algorithms are highly optimized.  On their own they are simple $O(n)$ algorithms but they can be called from higher level algorithms 
+At this point algorithms for initialization, clearing, zeroing, copying, comparing and setting small constants have been 
+established.  The next logical set of algorithms to develop are addition, subtraction and digit shifting algorithms.  These 
+algorithms make use of the lower level algorithms and are the cruicial building block for the multiplication algorithms.  It is very important 
+that these algorithms are highly optimized.  On their own they are simple $O(n)$ algorithms but they can be called from higher level algorithms 
 which easily places them at $O(n^2)$ or even $O(n^3)$ work levels.  
 
 MARK,SHIFTS
@@ -1203,7 +1235,7 @@ Historically that convention stems from the MPI library where ``s\_'' stood for 
 \hspace{+3mm}2.1  $min \leftarrow a.used$ \\
 \hspace{+3mm}2.2  $max \leftarrow b.used$ \\
 \hspace{+3mm}2.3  $x   \leftarrow b$ \\
-3.  If $c.alloc < max + 1$ then grow $c$ to hold at least $max + 1$ digits (\textit{hint: use mp\_grow}) \\
+3.  If $c.alloc < max + 1$ then grow $c$ to hold at least $max + 1$ digits (\textit{mp\_grow}) \\
 4.  If failed to grow $c$ return(\textit{MP\_MEM}) \\
 5.  $oldused \leftarrow c.used$ \\
 6.  $c.used \leftarrow max + 1$ \\
@@ -1221,7 +1253,7 @@ Historically that convention stems from the MPI library where ``s\_'' stood for 
 11.  if $olduse > max$ then \\
 \hspace{+3mm}11.1  for $n$ from $max + 1$ to $olduse - 1$ do \\
 \hspace{+6mm}11.1.1  $c_n \leftarrow 0$ \\
-12.  Clamp excess digits in $c$.  (\textit{hint: use mp\_clamp}) \\
+12.  Clamp excess digits in $c$.  (\textit{mp\_clamp}) \\
 13.  Return(\textit{MP\_OKAY}) \\
 \hline
 \end{tabular}
@@ -1231,32 +1263,33 @@ Historically that convention stems from the MPI library where ``s\_'' stood for 
 \end{figure}
 
 \textbf{Algorithm s\_mp\_add.}
-This algorithm is loosely based on algorithm 14.7 of \cite[pp. 594]{HAC} but has been extended to allow the inputs to have different magnitudes.  
-Coincidentally the description of algorithm A in \cite[pp. 266]{TAOCPV2} shares the same flaw as that from \cite{HAC}.  Even the MIX pseudo 
-machine code presented  \cite[pp. 266-267]{TAOCPV2} is incapable of handling inputs which are of different magnitudes.
+This algorithm is loosely based on algorithm 14.7 of HAC \cite[pp. 594]{HAC} but has been extended to allow the inputs to have different magnitudes.  
+Coincidentally the description of algorithm A in Knuth \cite[pp. 266]{TAOCPV2} shares the same deficiency as the algorithm from \cite{HAC}.  Even the 
+MIX pseudo  machine code presented by Knuth \cite[pp. 266-267]{TAOCPV2} is incapable of handling inputs which are of different magnitudes.
 
 Steps 1 and 2 will sort the two inputs based on their \textbf{used} digit count.  This allows the inputs to have varying magnitudes which not 
-only makes it more efficient than the trivial algorithm presented in the other references but more flexible.  The variable $min$ is given the lowest 
+only makes it more efficient than the trivial algorithm presented in the references but more flexible.  The variable $min$ is given the lowest 
 digit count while $max$ is given the highest digit count.  If both inputs have the same \textbf{used} digit count both $min$ and $max$ are 
-set to the same.  The variable $x$ is an \textit{alias} for the largest input and not meant to be a copy of it.  After the inputs are sorted steps 
-3 and 4 will ensure that the destination $c$ can accommodate the result.  The old \textbf{used} count from $c$ is copied to $oldused$ and the 
-new count is set to $max + 1$.  
+set to the same value.  The variable $x$ is an \textit{alias} for the largest input and not meant to be a copy of it.  After the inputs are sorted, 
+steps 3 and 4 will ensure that the destination $c$ can accommodate the result.  The old \textbf{used} count from $c$ is copied to 
+$oldused$ so that excess digits can be cleared later, and the new \textbf{used} count is set to $max+1$, so that a carry from the most significant 
+word can be handled.
 
-At step 7 the carry variable $u$ is set to zero and the first leg of the addition loop can begin.  The first step of the loop (\textit{8.1}) adds
+At step 7 the carry variable $u$ is set to zero and the first part of the addition loop can begin.  The first step of the loop (\textit{8.1}) adds
 digits from the two inputs together along with the carry variable $u$.  The following step extracts the carry bit by shifting the result of the
-preceding step right $lg(\beta)$ positions.  The shift to extract the carry is similar to how carry extraction works with decimal addition.
+preceding step right by $lg(\beta)$ positions.  The shift to extract the carry is similar to how carry extraction works with decimal addition.
 
 Consider adding $77$ to $65$, the first addition of the first column is $7 + 5$ which produces the result $12$.  The trailing digit of the result
 is $2 \equiv 12 \mbox{ (mod }10\mbox{)}$ and the carry is found by dividing (\textit{and ignoring the remainder}) $12$ by the radix or in this case $10$.  The
-division and multiplication of $10$ is simply a logical shift right or left respectively of the digits.  In otherwords the carry can be extracted
+division and multiplication of $10$ is simply a logical right or left shift, respectively, of the digits.  In otherwords the carry can be extracted
 by shifting one digit to the right.
 
 Note that $lg()$ is simply the base two logarithm such that $lg(2^k) = k$.  This implies that $lg(\beta)$ is the number of bits in a radix-$\beta$ 
-digit.  Therefore, a logical shift right of the single digit by $lg(\beta)$ will extract the carry.  The final step of the  loop reduces the digit 
+digit.  Therefore, a logical shift right of the summand by $lg(\beta)$ will extract the carry.  The final step of the loop reduces the digit 
 modulo the radix $\beta$ to ensure it is in range.
 
 After step 8 the smallest input (\textit{or both if they are the same magnitude}) has been exhausted.  Step 9 decides whether
-the inputs were of equal magnitude.  If not than another loop similar to that in step 8 must be executed.  The loop at step
+the inputs were of equal magnitude.  If not than another loop similar to that in step 8, must be executed.  The loop at step
 number 9.1 differs from the previous loop since it only adds the mp\_int $x$ along with the carry.  
 
 Step 10 finishes the addition phase by copying the final carry to the highest location in the result $c_{max}$.  Step 11 ensures that 
@@ -1264,12 +1297,12 @@ leading digits that were originally present in $c$ are cleared.  Finally excess 
 
 EXAM,bn_s_mp_add.c
 
-Lines @27,if@ to @35,}@ perform the initial sorting of the inputs and determine the $min$ and $max$ variables.  Note that $x$ is pointer to a 
+Lines @27,if@ to @35,}@ perform the initial sorting of the inputs and determine the $min$ and $max$ variables.  Note that $x$ is a pointer to a 
 mp\_int assigned to the largest input, in effect it is a local alias.  Lines @37,init@ to @42,}@ ensure that the destination is grown to 
 accomodate the result of the addition. 
 
-Similar to the implementation of mp\_copy this function uses the braced code and local aliases coding style.  The three aliases on 
-lines @56,tmpa@, @59,tmpb@ and @62,tmpc@ are the for the two inputs and destination respectively.  These aliases are used to ensure the
+Similar to the implementation of mp\_copy this function uses the braced code and local aliases coding style.  The three aliases that are on 
+lines @56,tmpa@, @59,tmpb@ and @62,tmpc@ represent the two inputs and destination variables respectively.  These aliases are used to ensure the
 compiler does not have to dereference $a$, $b$ or $c$ (respectively) to access the digits of the respective mp\_int.
 
 The initial carry $u$ is cleared on line @65,u = 0@, note that $u$ is of type mp\_digit which ensures type compatibility within the 
@@ -1287,8 +1320,12 @@ This algorithm as will be shown can be used to create functional signed addition
 MARK,GAMMA
 
 For this algorithm a new variable is required to make the description simpler.  Recall from section 1.3.1 that a mp\_digit must be able to represent
-the range $0 \le x < 2\beta$.  It is allowable that a mp\_digit represent a larger range of values.  For this algorithm we will assume that
-the variable $\gamma$ represents the number of bits available in a mp\_digit (\textit{this implies $2^{\gamma} > \beta$}).
+the range $0 \le x < 2\beta$ for the algorithms to work correctly.  However, it is allowable that a mp\_digit represent a larger range of values.  For 
+this algorithm we will assume that the variable $\gamma$ represents the number of bits available in a 
+mp\_digit (\textit{this implies $2^{\gamma} > \beta$}).  
+
+For example, the default for LibTomMath is to use a ``unsigned long'' for the mp\_digit ``type'' while $\beta = 2^{28}$.  In ISO C an ``unsigned long''
+data type must be able to represent $0 \le x < 2^{32}$ meaning that in this case $\gamma = 32$.
 
 \newpage\begin{figure}[!here]
 \begin{center}
@@ -1300,7 +1337,7 @@ the variable $\gamma$ represents the number of bits available in a mp\_digit (\t
 \hline \\
 1.  $min \leftarrow b.used$ \\
 2.  $max \leftarrow a.used$ \\
-3.  If $c.alloc < max$ then grow $c$ to hold at least $max$ digits.  (\textit{hint: use mp\_grow}) \\
+3.  If $c.alloc < max$ then grow $c$ to hold at least $max$ digits.  (\textit{mp\_grow}) \\
 4.  If the reallocation failed return(\textit{MP\_MEM}). \\
 5.  $oldused \leftarrow c.used$ \\ 
 6.  $c.used \leftarrow max$ \\
@@ -1317,7 +1354,7 @@ the variable $\gamma$ represents the number of bits available in a mp\_digit (\t
 10. if $oldused > max$ then do \\
 \hspace{3mm}10.1  for $n$ from $max$ to $oldused - 1$ do \\
 \hspace{6mm}10.1.1  $c_n \leftarrow 0$ \\
-11. Clamp excess digits of $c$.  (\textit{hint: use mp\_clamp}). \\
+11. Clamp excess digits of $c$.  (\textit{mp\_clamp}). \\
 12. Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
@@ -1334,29 +1371,30 @@ of the algorithm s\_mp\_add both other references lack discussion concerning var
 
 The initial sorting of the inputs is trivial in this algorithm since $a$ is guaranteed to have at least the same magnitude of $b$.  Steps 1 and 2 
 set the $min$ and $max$ variables.  Unlike the addition routine there is guaranteed to be no carry which means that the final result can be at 
-most $max$ digits in length as oppose to $max + 1$.  Similar to the addition algorithm the \textbf{used} count of $c$ is copied locally and 
+most $max$ digits in length as opposed to $max + 1$.  Similar to the addition algorithm the \textbf{used} count of $c$ is copied locally and 
 set to the maximal count for the operation.
 
 The subtraction loop that begins on step 8 is essentially the same as the addition loop of algorithm s\_mp\_add except single precision 
-subtraction is used instead.  Note the use of the $\gamma$ variable to extract the carry within the subtraction loops.  Under the assumption
-that two's complement single precision arithmetic is used this will successfully extract the carry.  
+subtraction is used instead.  Note the use of the $\gamma$ variable to extract the carry (\textit{also known as the borrow}) within the subtraction 
+loops.  Under the assumption that two's complement single precision arithmetic is used this will successfully extract the desired carry.  
 
-For example, consider subtracting $0101_2$ from
-$0100_2$ where $\gamma = 4$.  The least significant bit will force a carry upwards to the third bit which will be set to zero after the borrow.  After
-the very first bit has been subtracted $4 - 1 \equiv 0011_2$ will remain,  When the third bit of $0101_2$ is subtracted from the result it will cause
-another carry.  In this case though the carry will be forced to propagate all the way to the most significant bit.  
+For example, consider subtracting $0101_2$ from $0100_2$ where $\gamma = 4$ and $\beta = 2$.  The least significant bit will force a carry upwards to 
+the third bit which will be set to zero after the borrow.  After the very first bit has been subtracted $4 - 1 \equiv 0011_2$ will remain,  When the 
+third bit of $0101_2$ is subtracted from the result it will cause another carry.  In this case though the carry will be forced to propagate all the 
+way to the most significant bit.  
 
-Recall that $\beta < 2^{\gamma}$.  This means that if a carry does occur it will propagate all the way to the most significant bit.  Therefore a single
-logical shift right by $\gamma - 1$ positions is sufficient to extract the carry.  This method of carry extraction may seem awkward but the reason for 
-it becomes apparent when the implementation is discussed.  
+Recall that $\beta < 2^{\gamma}$.  This means that if a carry does occur just before the $lg(\beta)$'th bit it will propagate all the way to the most 
+significant bit.  Thus, the high order bits of the mp\_digit that are not part of the actual digit will either be all zero, or all one. All that
+is needed is a single zero or one bit for the carry.  Therefore a single logical shift right by $\gamma - 1$ positions is sufficient to extract the 
+carry.  This method of carry extraction may seem awkward but the reason for it becomes apparent when the implementation is discussed.  
 
 If $b$ has a smaller magnitude than $a$ then step 9 will force the carry and copy operation to propagate through the larger input $a$ into $c$.  Step
 10 will ensure that any leading digits of $c$ above the $max$'th position are zeroed.
 
 EXAM,bn_s_mp_sub.c
 
-Line @24,min@ and @25,max@ perform the initial hardcoded sorting.  In reality they are only aliases and are only used to make the source easier to 
-read.  Again the pointer alias optimization is used within this algorithm.  Lines @42,tmpa@, @43,tmpb@ and @44,tmpc@ initialize the aliases for 
+Line @24,min@ and @25,max@ perform the initial hardcoded sorting of the inputs.  In reality the $min$ and $max$ variables are only aliases and are only 
+used to make the source code easier to read.  Again the pointer alias optimization is used within this algorithm.  Lines @42,tmpa@, @43,tmpb@ and @44,tmpc@ initialize the aliases for 
 $a$, $b$ and $c$ respectively.
 
 The first subtraction loop occurs on lines @47,u = 0@ through @61,}@.  The theory behind the subtraction loop is exactly the same as that for
@@ -1367,7 +1405,7 @@ occurs from subtraction.  This carry extraction requires two relatively cheap op
 shift the most significant bit to the least significant bit thus extracting the carry with a single cheap operation.  This optimization only works on
 twos compliment machines which is a safe assumption to make.
 
-If $a$ has a higher magnitude than $b$ an additional loop (\textit{see lines @64,for@ through @73,}@}) is required to propagate the carry through
+If $a$ has a larger magnitude than $b$ an additional loop (\textit{see lines @64,for@ through @73,}@}) is required to propagate the carry through
 $a$ and copy the result to $c$.  
 
 \subsection{High Level Addition}
@@ -1376,9 +1414,9 @@ established.  This high level addition algorithm will be what other algorithms a
 types.  
 
 Recall from section 5.2 that an mp\_int represents an integer with an unsigned mantissa (\textit{the array of digits}) and a \textbf{sign} 
-flag.  A high level addition is actually performed as a series of eight seperate cases which can be optimized down to three unique cases.
+flag.  A high level addition is actually performed as a series of eight separate cases which can be optimized down to three unique cases.
 
-\newpage\begin{figure}[!here]
+\begin{figure}[!here]
 \begin{center}
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_add}. \\
@@ -1387,11 +1425,11 @@ flag.  A high level addition is actually performed as a series of eight seperate
 \hline \\
 1.  if $a.sign = b.sign$ then do \\
 \hspace{3mm}1.1  $c.sign \leftarrow a.sign$  \\
-\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{hint: use s\_mp\_add})\\
+\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{s\_mp\_add})\\
 2.  else do \\
-\hspace{3mm}2.1  if $\vert a \vert < \vert b \vert$ then do (\textit{hint: use mp\_cmp\_mag})  \\
+\hspace{3mm}2.1  if $\vert a \vert < \vert b \vert$ then do (\textit{mp\_cmp\_mag})  \\
 \hspace{6mm}2.1.1  $c.sign \leftarrow b.sign$ \\
-\hspace{6mm}2.1.2  $c \leftarrow \vert b \vert - \vert a \vert$ (\textit{hint: use s\_mp\_sub}) \\
+\hspace{6mm}2.1.2  $c \leftarrow \vert b \vert - \vert a \vert$ (\textit{s\_mp\_sub}) \\
 \hspace{3mm}2.2  else do \\
 \hspace{6mm}2.2.1  $c.sign \leftarrow a.sign$ \\
 \hspace{6mm}2.2.2  $c \leftarrow \vert a \vert - \vert b \vert$ \\
@@ -1406,9 +1444,9 @@ flag.  A high level addition is actually performed as a series of eight seperate
 \textbf{Algorithm mp\_add.}
 This algorithm performs the signed addition of two mp\_int variables.  There is no reference algorithm to draw upon from either \cite{TAOCPV2} or 
 \cite{HAC} since they both only provide unsigned operations.  The algorithm is fairly straightforward but restricted since subtraction can only 
-produce positive results.  Consider the following chart of possible inputs.
+produce positive results.
 
-\begin{figure}[!here]
+\begin{figure}[here]
 \begin{small}
 \begin{center}
 \begin{tabular}{|c|c|c|c|c|}
@@ -1432,10 +1470,11 @@ produce positive results.  Consider the following chart of possible inputs.
 \end{center}
 \end{small}
 \caption{Addition Guide Chart}
+\label{fig:AddChart}
 \end{figure}
 
-The chart lists all of the eight possible input combinations and is sorted to show that only three specific cases need to be handled.  The 
-return code of the unsigned operations at step 1.2, 2.1.2 and 2.2.2 are forwarded to step 3 to check for errors.  This simpliies the description
+Figure~\ref{fig:AddChart} lists all of the eight possible input combinations and is sorted to show that only three specific cases need to be handled.  The 
+return code of the unsigned operations at step 1.2, 2.1.2 and 2.2.2 are forwarded to step 3 to check for errors.  This simplifies the description
 of the algorithm considerably and best follows how the implementation actually was achieved.
 
 Also note how the \textbf{sign} is set before the unsigned addition or subtraction is performed.  Recall from the descriptions of algorithms
@@ -1456,7 +1495,7 @@ level functions do so.  Returning their return code is sufficient.
 \subsection{High Level Subtraction}
 The high level signed subtraction algorithm is essentially the same as the high level signed addition algorithm.  
 
-\begin{figure}[!here]
+\newpage\begin{figure}[!here]
 \begin{center}
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_sub}. \\
@@ -1465,11 +1504,11 @@ The high level signed subtraction algorithm is essentially the same as the high 
 \hline \\
 1.  if $a.sign \ne b.sign$ then do \\
 \hspace{3mm}1.1  $c.sign \leftarrow a.sign$ \\
-\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{hint: use s\_mp\_add}) \\
+\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{s\_mp\_add}) \\
 2.  else do \\
-\hspace{3mm}2.1  if $\vert a \vert \ge \vert b \vert$ then do (\textit{hint: use mp\_cmp\_mag}) \\
+\hspace{3mm}2.1  if $\vert a \vert \ge \vert b \vert$ then do (\textit{mp\_cmp\_mag}) \\
 \hspace{6mm}2.1.1  $c.sign \leftarrow a.sign$ \\
-\hspace{6mm}2.1.2  $c \leftarrow \vert a \vert  - \vert b \vert$ (\textit{hint: use s\_mp\_sub}) \\
+\hspace{6mm}2.1.2  $c \leftarrow \vert a \vert  - \vert b \vert$ (\textit{s\_mp\_sub}) \\
 \hspace{3mm}2.2  else do \\
 \hspace{6mm}2.2.1  $c.sign \leftarrow  \left \lbrace \begin{array}{ll}
                               MP\_ZPOS &  \mbox{if }a.sign = MP\_NEG \\
@@ -1489,7 +1528,7 @@ This algorithm performs the signed subtraction of two inputs.  Similar to algori
 \cite{HAC}.  Also this algorithm is restricted by algorithm s\_mp\_sub.  The following chart lists the eight possible inputs and
 the operations required.
 
-\newpage\begin{figure}[!here]
+\begin{figure}[!here]
 \begin{small}
 \begin{center}
 \begin{tabular}{|c|c|c|c|c|}
@@ -1542,7 +1581,7 @@ operation to perform.  A single precision logical shift left is sufficient to mu
 \textbf{Input}.   One mp\_int $a$ \\
 \textbf{Output}.  $b = 2a$. \\
 \hline \\
-1.  If $b.alloc < a.used + 1$ then grow $b$ to hold $a.used + 1$ digits.  (\textit{hint: use mp\_grow}) \\
+1.  If $b.alloc < a.used + 1$ then grow $b$ to hold $a.used + 1$ digits.  (\textit{mp\_grow}) \\
 2.  If the reallocation failed return(\textit{MP\_MEM}). \\
 3.  $oldused \leftarrow b.used$ \\
 4.  $b.used \leftarrow a.used$ \\
@@ -1552,7 +1591,7 @@ operation to perform.  A single precision logical shift left is sufficient to mu
 \hspace{3mm}6.2  $b_n \leftarrow (a_n << 1) + r \mbox{ (mod }\beta\mbox{)}$ \\
 \hspace{3mm}6.3  $r \leftarrow rr$ \\
 7.  If $r \ne 0$ then do \\
-\hspace{3mm}7.1  $b_{a.used} = 1$ \\
+\hspace{3mm}7.1  $b_{n + 1} \leftarrow r$ \\
 \hspace{3mm}7.2  $b.used \leftarrow b.used + 1$ \\
 8.  If $b.used < oldused - 1$ then do \\
 \hspace{3mm}8.1  for $n$ from $b.used$ to $oldused - 1$ do \\
@@ -1580,8 +1619,8 @@ obtain what will be the carry for the next iteration.  Step 6.2 calculates the $
 the previous carry.  Recall from ~SHIFTS~ that $a_n << 1$ is equivalent to $a_n \cdot 2$.  An iteration of the addition loop is finished with 
 forwarding the carry to the next iteration.
 
-Step 7 takes care of any final carry by setting the $a.used$'th digit of the result to one and augmenting the \textbf{used} count.  Step 8 clears
-any original leading digits of $b$.
+Step 7 takes care of any final carry by setting the $a.used$'th digit of the result to the carry and augmenting the \textbf{used} count of $b$.  
+Step 8 clears any leading digits of $b$ in case it originally had a larger magnitude than $a$.
 
 EXAM,bn_mp_mul_2.c
 
@@ -1599,7 +1638,7 @@ A division by two can just as easily be accomplished with a logical shift right 
 \textbf{Input}.   One mp\_int $a$ \\
 \textbf{Output}.  $b = a/2$. \\
 \hline \\
-1.  If $b.alloc < a.used$ then grow $b$ to hold $a.used$ digits.  (\textit{hint: use mp\_grow}) \\
+1.  If $b.alloc < a.used$ then grow $b$ to hold $a.used$ digits.  (\textit{mp\_grow}) \\
 2.  If the reallocation failed return(\textit{MP\_MEM}). \\
 3.  $oldused \leftarrow b.used$ \\
 4.  $b.used \leftarrow a.used$ \\
@@ -1612,7 +1651,8 @@ A division by two can just as easily be accomplished with a logical shift right 
 \hspace{3mm}7.1  for $n$ from $b.used$ to $oldused - 1$ do \\
 \hspace{6mm}7.1.1  $b_n \leftarrow 0$ \\
 8.  $b.sign \leftarrow a.sign$ \\
-9.  Return(\textit{MP\_OKAY}).\\
+9.  Clamp excess digits of $b$.  (\textit{mp\_clamp}) \\
+10.  Return(\textit{MP\_OKAY}).\\
 \hline
 \end{tabular}
 \end{center}
@@ -1624,7 +1664,7 @@ A division by two can just as easily be accomplished with a logical shift right 
 This algorithm will divide an mp\_int by two using logical shifts to the right.  Like mp\_mul\_2 it uses a modified low level addition
 core as the basis of the algorithm.  Unlike mp\_mul\_2 the shift operations work from the leading digit to the trailing digit.  The algorithm
 could be written to work from the trailing digit to the leading digit however, it would have to stop one short of $a.used - 1$ digits to prevent
-reading passed the end of the array of digits.
+reading past the end of the array of digits.
 
 Essentially the loop at step 6 is similar to that of mp\_mul\_2 except the logical shifts go in the opposite direction and the carry is at the 
 least significant bit not the most significant bit.  
@@ -1653,10 +1693,10 @@ multiplying by the integer $\beta$.
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_lshd}. \\
 \textbf{Input}.   One mp\_int $a$ and an integer $b$ \\
-\textbf{Output}.  $a \leftarrow a \cdot \beta^b$ (Multiply by $x^b$). \\
+\textbf{Output}.  $a \leftarrow a \cdot \beta^b$ (equivalent to multiplication by $x^b$). \\
 \hline \\
 1.  If $b \le 0$ then return(\textit{MP\_OKAY}). \\
-2.  If $a.alloc < a.used + b$ then grow $a$ to at least $a.used + b$ digits.  (\textit{hint: use mp\_grow}). \\
+2.  If $a.alloc < a.used + b$ then grow $a$ to at least $a.used + b$ digits.  (\textit{mp\_grow}). \\
 3.  If the reallocation failed return(\textit{MP\_MEM}). \\
 4.  $a.used \leftarrow a.used + b$ \\
 5.  $i \leftarrow a.used - 1$ \\
@@ -1677,8 +1717,11 @@ multiplying by the integer $\beta$.
 
 \textbf{Algorithm mp\_lshd.}
 This algorithm multiplies an mp\_int by the $b$'th power of $x$.  This is equivalent to multiplying by $\beta^b$.  The algorithm differs 
-from the other algorithms presented so far as it performs the operation in place instead storing the result in a seperate location.  The algorithm
-will return success immediately if $b \le 0$ since the rest of algorithm is only valid when $b > 0$.  
+from the other algorithms presented so far as it performs the operation in place instead storing the result in a separate location.  The
+motivation behind this change is due to the way this function is typically used.  Algorithms such as mp\_add store the result in an optionally
+different third mp\_int because the original inputs are often still required.  Algorithm mp\_lshd (\textit{and similarly algorithm mp\_rshd}) is
+typically used on values where the original value is no longer required.  The algorithm will return success immediately if 
+$b \le 0$ since the rest of algorithm is only valid when $b > 0$.  
 
 First the destination $a$ is grown as required to accomodate the result.  The counters $i$ and $j$ are used to form a \textit{sliding window} over
 the digits of $a$ of length $b$.  The head of the sliding window is at $i$ (\textit{the leading digit}) and the tail at $j$ (\textit{the trailing digit}).  
@@ -1691,8 +1734,8 @@ FIGU,sliding_window,Sliding Window Movement
 EXAM,bn_mp_lshd.c
 
 The if statement on line @24,if@ ensures that the $b$ variable is greater than zero.  The \textbf{used} count is incremented by $b$ before
-the copy loop begins.  This elminates the need for an additional variable in the for loop.  The variable $tmpa$ on line @42,tmpa@ is an alias
-for the leading digit while $tmpaa$ on line @45,tmpaa@ is an alias for the trailing edge.  The aliases form a window of exactly $b$ digits
+the copy loop begins.  This elminates the need for an additional variable in the for loop.  The variable $top$ on line @42,top@ is an alias
+for the leading digit while $bottom$ on line @45,bottom@ is an alias for the trailing edge.  The aliases form a window of exactly $b$ digits
 over the input.  
 
 \subsection{Division by $x$}
@@ -1709,7 +1752,7 @@ Division by powers of $x$ is easily achieved by shifting the digits right and re
 \hline \\
 1.  If $b \le 0$ then return. \\
 2.  If $a.used \le b$ then do \\
-\hspace{3mm}2.1  Zero $a$.  (\textit{hint: use mp\_zero}). \\
+\hspace{3mm}2.1  Zero $a$.  (\textit{mp\_zero}). \\
 \hspace{3mm}2.2  Return. \\
 3.  $i \leftarrow 0$ \\
 4.  $j \leftarrow b$ \\
@@ -1719,7 +1762,7 @@ Division by powers of $x$ is easily achieved by shifting the digits right and re
 \hspace{3mm}5.3  $j \leftarrow j + 1$ \\
 6.  for $n$ from $a.used - b$ to $a.used - 1$ do \\
 \hspace{3mm}6.1  $a_n \leftarrow 0$ \\
-7.  Clamp excess digits.  (\textit{hint: use mp\_clamp}). \\
+7.  $a.used \leftarrow a.used - b$ \\
 8.  Return. \\
 \hline
 \end{tabular}
@@ -1739,12 +1782,13 @@ After the trivial cases of inputs have been handled the sliding window is setup.
 is $b$ digits wide is used to copy the digits.  Unlike mp\_lshd the window slides in the opposite direction from the trailing to the leading digit.  
 Also the digits are copied from the leading to the trailing edge.
 
-Once the window copy is complete the upper digits must be zeroed.  Finally algorithm mp\_clamp is used to trim excess digits.
+Once the window copy is complete the upper digits must be zeroed and the \textbf{used} count decremented.
 
 EXAM,bn_mp_rshd.c
 
-The only noteworthy element of this routine is the lack of a return type.  This function cannot fail and as such it is more optimal to not
-return anything.
+The only noteworthy element of this routine is the lack of a return type.  
+
+-- Will update later to give it a return type...Tom
 
 \section{Powers of Two}
 
@@ -1762,11 +1806,11 @@ shifts $k$ times to achieve a multiplication by $2^{\pm k}$ a mixture of whole d
 \textbf{Input}.   One mp\_int $a$ and an integer $b$ \\
 \textbf{Output}.  $c \leftarrow a \cdot 2^b$. \\
 \hline \\
-1.  $c \leftarrow a$.  (\textit{hint: use mp\_copy}) \\
+1.  $c \leftarrow a$.  (\textit{mp\_copy}) \\
 2.  If $c.alloc < c.used + \lfloor b / lg(\beta) \rfloor + 2$ then grow $c$ accordingly. \\
 3.  If the reallocation failed return(\textit{MP\_MEM}). \\
 4.  If $b \ge lg(\beta)$ then \\
-\hspace{3mm}4.1  $c \leftarrow c \cdot \beta^{\lfloor b / lg(\beta) \rfloor}$ (\textit{hint: use mp\_lshd}). \\
+\hspace{3mm}4.1  $c \leftarrow c \cdot \beta^{\lfloor b / lg(\beta) \rfloor}$ (\textit{mp\_lshd}). \\
 \hspace{3mm}4.2  If step 4.1 failed return(\textit{MP\_MEM}). \\
 5.  $d \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\
 6.  If $d \ne 0$ then do \\
@@ -1795,7 +1839,8 @@ First the algorithm will multiply $a$ by $x^{\lfloor b / lg(\beta) \rfloor}$ whi
 $\beta$.  For example, if $b = 37$ and $\beta = 2^{28}$ then this step will multiply by $x$ leaving a multiplication by $2^{37 - 28} = 2^{9}$ 
 left.
 
-The logarithm of the residue is calculated on step 5.  If it is non-zero a modified shift loop is used to calculate the remaining product.  
+After the digits have been shifted appropriately at most $lg(\beta) - 1$ shifts are left to perform.  Step 5 calculates the number of remaining shifts 
+required.  If it is non-zero a modified shift loop is used to calculate the remaining product.  
 Essentially the loop is a generic version of algorith mp\_mul2 designed to handle any shift count in the range $1 \le x < lg(\beta)$.  The $mask$
 variable is used to extract the upper $d$ bits to form the carry for the next iteration.  
 
@@ -1817,13 +1862,13 @@ Notes to be revised when code is updated. -- Tom
 \textbf{Output}.  $c \leftarrow \lfloor a / 2^b \rfloor, d \leftarrow a \mbox{ (mod }2^b\mbox{)}$. \\
 \hline \\
 1.  If $b \le 0$ then do \\
-\hspace{3mm}1.1  $c \leftarrow a$ (\textit{hint: use mp\_copy}) \\
-\hspace{3mm}1.2  $d \leftarrow 0$ (\textit{hint: use mp\_zero}) \\
+\hspace{3mm}1.1  $c \leftarrow a$ (\textit{mp\_copy}) \\
+\hspace{3mm}1.2  $d \leftarrow 0$ (\textit{mp\_zero}) \\
 \hspace{3mm}1.3  Return(\textit{MP\_OKAY}). \\
 2.  $c \leftarrow a$ \\
-3.  $d \leftarrow a \mbox{ (mod }2^b\mbox{)}$ (\textit{hint: use mp\_mod\_2d}) \\
+3.  $d \leftarrow a \mbox{ (mod }2^b\mbox{)}$ (\textit{mp\_mod\_2d}) \\
 4.  If $b \ge lg(\beta)$ then do \\
-\hspace{3mm}4.1  $c \leftarrow \lfloor c/\beta^{\lfloor b/lg(\beta) \rfloor} \rfloor$ (\textit{hint: use mp\_rshd}). \\
+\hspace{3mm}4.1  $c \leftarrow \lfloor c/\beta^{\lfloor b/lg(\beta) \rfloor} \rfloor$ (\textit{mp\_rshd}). \\
 5.  $k \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\
 6.  If $k \ne 0$ then do \\
 \hspace{3mm}6.1  $mask \leftarrow 2^k$ \\
@@ -1832,7 +1877,7 @@ Notes to be revised when code is updated. -- Tom
 \hspace{6mm}6.3.1  $rr \leftarrow c_n \mbox{ (mod }mask\mbox{)}$ \\
 \hspace{6mm}6.3.2  $c_n \leftarrow (c_n >> k) + (r << (lg(\beta) - k))$ \\
 \hspace{6mm}6.3.3  $r \leftarrow rr$ \\
-7.  Clamp excess digits of $c$.  (\textit{hint: use mp\_clamp}) \\
+7.  Clamp excess digits of $c$.  (\textit{mp\_clamp}) \\
 8.  Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
@@ -1850,7 +1895,8 @@ EXAM,bn_mp_div_2d.c
 
 The implementation of algorithm mp\_div\_2d is slightly different than the algorithm specifies.  The remainder $d$ may be optionally 
 ignored by passing \textbf{NULL} as the pointer to the mp\_int variable.    The temporary mp\_int variable $t$ is used to hold the 
-result of the remainder operation until the end.  This allows $d = a$ to be true without overwriting the input before they are no longer required.  
+result of the remainder operation until the end.  This allows $d$ and $a$ to represent the same mp\_int without modifying $a$ before
+the quotient is obtained.
 
 The remainder of the source code is essentially the same as the source code for mp\_mul\_2d.  (-- Fix this paragraph up later, Tom).
 
@@ -1868,10 +1914,10 @@ algorithm benefits from the fact that in twos complement arithmetic $a \mbox{ (m
 \textbf{Output}.  $c \leftarrow a \mbox{ (mod }2^b\mbox{)}$. \\
 \hline \\
 1.  If $b \le 0$ then do \\
-\hspace{3mm}1.1  $c \leftarrow 0$ (\textit{hint: use mp\_zero}) \\
+\hspace{3mm}1.1  $c \leftarrow 0$ (\textit{mp\_zero}) \\
 \hspace{3mm}1.2  Return(\textit{MP\_OKAY}). \\
 2.  If $b > a.used \cdot lg(\beta)$ then do \\
-\hspace{3mm}2.1  $c \leftarrow a$ (\textit{hint: use mp\_copy}) \\
+\hspace{3mm}2.1  $c \leftarrow a$ (\textit{mp\_copy}) \\
 \hspace{3mm}2.2  Return the result of step 2.1. \\
 3.  $c \leftarrow a$ \\
 4.  If step 3 failed return(\textit{MP\_MEM}). \\
@@ -1879,7 +1925,8 @@ algorithm benefits from the fact that in twos complement arithmetic $a \mbox{ (m
 \hspace{3mm}5.1  $c_n \leftarrow 0$ \\
 6.  $k \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\
 7.  $c_{\lfloor b / lg(\beta) \rfloor} \leftarrow c_{\lfloor b / lg(\beta) \rfloor} \mbox{ (mod }2^{k}\mbox{)}$. \\
-8.  Return(\textit{MP\_OKAY}). \\
+8.  Clamp excess digits of $c$.  (\textit{mp\_clamp}) \\
+9.  Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
 \end{center}
@@ -1917,10 +1964,6 @@ $\left [ 5 \right ] $ & Improve the previous algorithm to have a working time of
                       & $O \left (2^{(k-1)}n + \left ({2n^2 \over k} \right ) \right )$ for an appropriate choice of $k$.  Again ignore \\
                       & the cost of addition. \\
                       & \\
-$\left [ 1 \right ] $ & There exists an improvement on the previous algorithm to \\
-                      & slightly reduce the number of additions required.  Modify the \\
-                      & previous algorithm to include this improvement. \\
-                      & \\
 $\left [ 2 \right ] $ & Devise a chart to find optimal values of $k$ for the previous problem \\
                       & for $n = 64 \ldots 1024$ in steps of $64$. \\
                       & \\
@@ -1998,8 +2041,10 @@ Compute the product. \\
 \caption{Algorithm s\_mp\_mul\_digs}
 \end{figure}
 
+
+
 \textbf{Algorithm s\_mp\_mul\_digs.}
-This algorithm computes the unsigned product of two inputs $a$ and $c$ limited to an output precision of $digs$ digits.  While it may seem
+This algorithm computes the unsigned product of two inputs $a$ and $b$ limited to an output precision of $digs$ digits.  While it may seem
 a bit awkward to modify the function from its simple $O(n^2)$ description the usefulness of partial multipliers will arise in a future 
 algorithm.  The algorithm is loosely based on algorithm 14.12 from \cite[pp. 595]{HAC} and is similar to Algorithm M \cite[pp. 268]{TAOCPV2}.  The
 algorithm differs from those cited references because it can produce a variable output precision regardless of the precision of the inputs.
@@ -2063,7 +2108,8 @@ MARK,COMBA
 One of the huge drawbacks of the ``baseline'' algorithms is that at the $O(n^2)$ level the carry must be computed and propagated upwards.  This
 makes the nested loop very sequential and hard to unroll and implement in parallel.  The ``Comba'' method is named after little known 
 (\textit{in cryptographic venues}) Paul G. Comba where in \cite{COMBA} a method of implementing fast multipliers that do not require nested 
-carry fixup operations was presented.
+carry fixup operations was presented.  As an interesting aside it seems that Paul Barrett  describes a similar technique in
+his 1986 paper \cite{BARRETT} which was written five years before \cite{COMBA}.  
 
 At the heart of algorithm is once again the long-hand algorithm for multiplication.  Except in this case a slight twist is placed on how
 the columns of the result are produced.  In the standard long-hand algorithm rows of products are produced then added together to form the 
@@ -2151,7 +2197,7 @@ which is much larger than the typical $2^{100}$ to $2^{4000}$ range most public 
 \textbf{Output}.  $c \leftarrow \vert a \vert \cdot \vert b \vert \mbox{ (mod }\beta^{digs}\mbox{)}$. \\
 \hline \\
 Place an array of \textbf{MP\_WARRAY} double precision digits named $\hat W$ on the stack. \\
-1.  If $c.alloc < digs$ then grow $c$ to $digs$ digits. (\textit{hint: use mp\_grow}) \\
+1.  If $c.alloc < digs$ then grow $c$ to $digs$ digits. (\textit{mp\_grow}) \\
 2.  If step 1 failed return(\textit{MP\_MEM}).\\
 \\
 Zero the temporary array $\hat W$. \\
@@ -2180,7 +2226,7 @@ Zero excess digits. \\
 10.  If $digs < oldused$ then do \\
 \hspace{3mm}10.1  for $n$ from $digs$ to $oldused - 1$ do \\
 \hspace{6mm}10.1.1  $c_n \leftarrow 0$ \\
-11.  Clamp excessive digits of $c$.  (\textit{hint: use mp\_clamp}) \\
+11.  Clamp excessive digits of $c$.  (\textit{mp\_clamp}) \\
 12.  Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
@@ -2227,97 +2273,116 @@ baseline method there are dependency stalls as the algorithm must wait for the m
 digit.  As a result fewer of the often multiple execution units\footnote{The AMD Athlon has three execution units and the Intel P4 has four.} can
 be simultaneously used.  
 
-\subsection{Multiplication at New Bounds by Karatsuba Method}
-So far two methods of multiplication have been presented.  Both of the algorithms require asymptotically $O(n^2)$ time to multiply two $n$-digit 
-numbers together.  While the Comba method is much faster than the baseline algorithm it still requires far too much time to multiply 
-large inputs together.  In fact it was not until \cite{KARA} in 1962 that a faster algorithm had been proposed at all.
-
-The idea behind Karatsubas method is that an input can be represented in polynomial basis as two halves then multiplied.  For example, if 
-$f(x) = ax + b$ and $g(x) = cx + b$ then the product of the two polynomials $h(x) = f(x)g(x)$ will allow $h(\beta) = (f(\beta))(g(\beta))$.  
-
-So how does this help?  First expand the product $h(x)$.
+\subsection{Polynomial Basis Multiplication}
+To break the $O(n^2)$ barrier in multiplication requires a completely different look at integer multiplication.  In the following algorithms
+the use of polynomial basis representation for two integers $a$ and $b$ as $f(x) = \sum_{i=0}^{n} a_i x^i$ and  
+$g(x) = \sum_{i=0}^{n} b_i x^i$. respectively, is required.  In this system both $f(x)$ and $g(x)$ have $n + 1$ terms and are of the $n$'th degree.
+ 
+The product $a \cdot b \equiv f(x) \cdot g(x)$ is the polynomial $W(x) = \sum_{i=0}^{2n} w_i x^i$.  The coefficients $w_i$ will
+directly yield the desired product when $\beta$ is substituted for $x$.  The direct solution to solve for the $2n + 1$ coefficients
+requires $O(n^2)$ time and is would be in practice slower than the Comba technique.
+
+However, numerical analysis theory will indicate that only $2n + 1$ points in $W(x)$ are required to provide $2n + 1$ knowns for the $2n + 1$ unknowns.  
+This means by finding $\zeta_y = W(y)$ for $2n + 1$ small values of $y$ the coefficients of $W(x)$ can be found with trivial Gaussian elimination.  
+Since the polynomial $W(x)$ is unknown the equivalent $\zeta_y = f(y) \cdot g(y)$ is used in its place.  
+
+The benefit of this technique stems from the fact that $f(y)$ and $g(y)$ are much smaller than either $a$ or $b$ respectively.  In fact if 
+both polynomials have $n + 1$ terms then the multiplicands will be $n$  times smaller than the inputs.  Even if $2n + 1$ multiplications are required
+since they are of smaller values the algorithm is still faster.
+
+When picking points to gather relations there are always three obvious points to choose, $y = 0, 1$ and $ \infty$.  The $\zeta_0$ term
+is simply the product $W(0) = w_0 = a_0 \cdot b_0$.  The $\zeta_1$ term is the product 
+$W(1) = \left (\sum_{i = 0}^{n} a_i \right ) \left (\sum_{i = 0}^{n} b_i \right )$.  The third point $\zeta_{\infty}$ is less obvious but rather
+simple to explain.  The $2n + 1$'th coefficient of $W(x)$ is numerically equivalent to the most significant column in an integer multiplication.  
+The point at $\infty$ is used symbolically to represent the most significant column, that is $W(\infty) = w_{2n + 1} = a_nb_n$.  Note that the 
+points at $y = 0$ and $\infty$ yield the coefficients $w_0$ and $w_{2n + 1}$ directly.
+
+If more points are required they should be of small input values which are powers of two such as 
+$2^q$ and the related \textit{mirror points} $\left (2^q \right )^{2n}  \cdot \zeta_{2^{-q}}$ for small values of $q$.  Using such 
+points will allow the values of $f(y)$ and $g(y)$ to be independently calculated using only left shifts.
+
+As a general rule of the algorithm when the inputs are split into $n$ parts each there are $2n - 1$ multiplications.  Each multiplication is of 
+multiplicands that have $n$ times fewer digits than the inputs.  The asymptotic running time of this algorithm is 
+$O \left ( k^{lg_n(2n - 1)} \right )$ for $k$ digit inputs (\textit{assuming they have the same number of digits}).  The following table 
+summarizes the exponents for various values of $n$.
 
+\newpage\begin{figure}
 \begin{center}
-\begin{tabular}{rcl}
-$h(x)$ & $=$ & $f(x)g(x)$ \\
-       & $=$ & $(ax + b)(cx + d)$ \\
-       & $=$ & $acx^2 + adx + bcx + bd$ \\
+\begin{tabular}{|c|c|c|}
+\hline \textbf{Split into $n$ Parts} & \textbf{Exponent}  & \textbf{Notes}\\
+\hline $2$ & $1.584962501$ & This is Karatsuba Multiplication. \\
+\hline $3$ & $1.464973520$ & This is Toom-Cook Multiplication. \\
+\hline $4$ & $1.403677461$ &\\
+\hline $5$ & $1.365212389$ &\\
+\hline $10$ & $1.278753601$ &\\
+\hline $100$ & $1.149426538$ &\\
+\hline $1000$ & $1.100270931$ &\\
+\hline $10000$ & $1.075252070$ &\\
+\hline
 \end{tabular}
 \end{center}
+\caption{Asymptotic Running Time of Polynomial Basis Multiplication}
+\end{figure}
 
-The next equation is a bit of genius on the part of Karatsuba.  He proved that the previous equation is equivalent to 
-
-\begin{equation}
-h(x) = acx^2 + ((a - c)(b - d) + bd + ac)x + bd
-\end{equation}
+At first it may seem like a good idea to choose $n = 1000$ since afterall the exponent is approximately $1.1$.  However, the overhead
+of solving for the 2001 terms of $W(x)$ will certainly consume any savings the algorithm could offer for all but exceedingly large
+numbers.  
 
-Essentially the proof lies in some fairly light algebraic number theory (\textit{see \cite{KARAP} for details}) that is not important for
-the discussion.  At first glance it appears that the Karatsuba method is actually harder than the straight $O(n^2)$ approach.  
-However, further investigation will prove otherwise.  
+\subsubsection{Cutoff Point}
+The polynomial basis multiplication algorithms all require fewer single precision multiplications than a straight Comba approach.  However, 
+the algorithms incur an overhead (\textit{at the $O(n)$ work level}) since they require a system of equations to be solved.  This makes them costly to 
+use with small inputs.  
 
-The first important observation is that both $f(x)$ and $g(x)$ are the polynomial basis representation of two-digit numbers.  This means that 
-$\left < a, b, c, d \right >$ are single digit values.  Using either the baseline or straight polynomial multiplication the old method requires
-$O \left (4(n/2)^2 \right ) = O(n^2)$ single precision multiplications.  Looking closer at Karatsubas equation there are only three unique multiplications 
-required which are $ac$, $bd$ and $(a - c)(b - d)$.  As a result only $O \left (3 \cdot (n/2)^2 \right ) = O \left ( {3 \over 4}n^2 \right )$ 
-multiplications are required.  
+Let $m$ represent the number of digits in the multiplicands (\textit{assume both multiplicands have the same number of digits}).  There exists a 
+point $y$ such that when $m < y$ the polynomial basis algorithms are more costly than Comba, when $m = y$ they are roughly the same cost and 
+when $m > y$ the Comba methods are slower than the polynomial basis algorithms.  
 
-So far the algorithm has been discussed from the point of view of ``two-digit'' numbers.  However, there is no reason why two digits implies a range of 
-$\beta^2$.  It could just as easily represent a range of $\left (\beta^k \right)^2$ as well.  For example, the polynomial 
-$f(x) = a_3x^3 + a_2x^2 + a_1x + a_0$ could also be written as $f'(x) = a'_1x + a'_0$ where $f(\beta) = f'(\beta^2)$.  Fortunately representing an
-integer which is already in an array of radix-$\beta$ digits in polynomial basis in terms of a power of $\beta$ is very simple.  
+The exact location of $y$ depends on several key architectural elements of the computer platform in question.
 
-\subsubsection{Recursion}
-The Karatsuba multiplication algorithm can be applied to practically any size of input.  Therefore, it is possible that the Karatsuba method itself
-be used for the three multiplications required.  For example, when multiplying two four-digit numbers there will be three multiplications of two-digit
-numbers.  In this case the smaller multiplication requires $p(n) = {3 \over 4}n^2$ time to complete while the larger multiplication requires
-$q(n) = 3 \cdot p(n/2)$ multiplications.  
+\begin{enumerate}
+\item  The ratio of clock cycles for single precision multiplication versus other simpler operations such as addition, shifting, etc.  For example
+on the AMD Athlon the ratio is roughly $17 : 1$ while on the Intel P4 it is $29 : 1$.  The higher the ratio in favour of multiplication the lower
+the cutoff point $y$ will be.  
 
-By expanding $q(n)$ the following equation is achieved. 
+\item  The complexity of the linear system of equations (\textit{for the coefficients of $W(x)$}) is.  Generally speaking as the number of splits
+grows the complexity grows substantially.  Ideally solving the system will only involve addition, subtraction and shifting of integers.  This
+directly reflects on the ratio previous mentioned.
 
-\begin{center}
-\begin{tabular}{rcl}
-$q(n)$ & $=$ & $3 \cdot p(n/2)$ \\
-       & $=$ & $3 \cdot (3 \cdot ((n/2)/2)^2)$ \\
-       & $=$ & $9 \cdot (n/4)^2$ \\
-       & $=$ & ${9 \over 16}n^2$ \\
-\end{tabular}
-\end{center}
+\item  To a lesser extent memory bandwidth and function call overheads.  Provided the values are in the processor cache this is less of an
+influence over the cutoff point.
 
-The generic expression for the multiplicand is simply $\left ( {3 \over 4} \right )^k$ for $k \ge 1$ recurisions.  The maximal number of recursions
-is approximately $lg(n)$.  Putting this all in terms of a base $n$ logarithm the asymptotic running time can be deduced.
+\end{enumerate}
 
-\begin{center}
-\begin{tabular}{rcl}
-$lg_n \left ( \left ( {3 \over 4} \right )^{lg_2 n} \cdot n^2 \right )$ & $=$ & $lg_2 n \cdot lg_n \left ( { 3 \over 4 } \right ) + 2$ \\
-                                                                        & $=$ & $\left ( {log N \over log 2} \right ) \cdot \left ( {log \left ( {3 \over 4} \right ) \over log N } \right ) + 2$ \\
-                                                                        & $=$ & ${ log 3 - log 2^2 + 2 \cdot log 2} \over log 2$ \\
-                                                                        & $=$ & $log 3 \over log 2$ \\
-\end{tabular}
-\end{center}
+A clean cutoff point separation occurs when a point $y$ is found such that all of the cutoff point conditions are met.  For example, if the point
+is too low then there will be values of $m$ such that $m > y$ and the Comba method is still faster.  Finding the cutoff points is fairly simple when
+a high resolution timer is available.  
 
-Which leads to a running time of $O \left ( n^{lg(3)} \right )$ which is approximately $O(n^{1.584})$.  This can lead to 
-impressive savings with fairly moderate sized numbers.  For example, when multiplying two 128-digit numbers the Karatsuba 
-method saves $14,197$ (\textit{or $86\%$ of the total}) single precision multiplications.  
+\subsection{Karatsuba Multiplication}
+Karatsuba multiplication \cite{KARA} when originally proposed in 1962 was among the first set of algorithms to break the $O(n^2)$ barrier for
+general purpose multiplication.  Given two polynomial basis representations $f(x) = ax + b$ and $g(x) = cx + d$ Karatsuba proved with 
+light number theory \cite{KARAP} that the following polynomial is equivalent to multiplication of the two integers the polynomials represent.
 
-The immediate question becomes why not simply use Karatsuba multiplication all the time and forget about the baseline and Comba algorithms? 
+\begin{equation}
+f(x) \cdot g(x) = acx^2 + ((a - b)(c - d) + ac + bd)x + bd
+\end{equation}
 
-\subsubsection{Overhead}
-While the Karatsuba method saves on the number of single precision multiplications required this savings is not entirely free.  The product
-of three half size products must be stored somewhere as well as four additions and two subtractions performed.  These operations incur sufficient
-overhead that often for fairly trivial sized inputs the Karatsuba method is slower.
+Using the observation that $ac$ and $bd$ could be re-used only three half sized multiplications would be required to produce the product.  Applying
+this recursively the work factor becomes $O(n^{lg(3)})$ which is substantially better than the work factor $O(n^2)$ of the Comba technique.  It turns 
+out what Karatsuba did not know or at least did not publish was that this is simply polynomial basis multiplication with the points 
+$\zeta_0$, $\zeta_{\infty}$ and $-\zeta_{-1}$.  Consider the resultant system of equations.
 
-\index{cutoff point}
-The \textit{cutoff point} for Karatsuba multiplication is the point at which the Karatsuba multiplication and baseline (\textit{or Comba}) meet.  
-For the purposes of this discussion call this value $x$.  For any input with $n$ digits such that $n < x$ Karatsuba multiplication will be slower 
-and for $n > x$ it will be faster.  Often the break between the two algorithms is not so clean cut in reality.  The cleaner the cut the more 
-efficient multiplication will be which is why tuning the multiplication is a very important process.  For example, a properly tuned Karatsuba 
-multiplication algorithm can multiply two $4,096$ bit numbers up to five times faster on an Athlon processor compared to the standard baseline
-algorithm.  
+\begin{center}
+\begin{tabular}{rcrcrcrc}
+$\zeta_{0}$ &      $=$ &  &  &  & & $w_0$ \\
+$-\zeta_{-1}$ &    $=$ & $-w_2$ & $+$ & $w_1$ & $-$ & $w_0$ \\
+$\zeta_{\infty}$ & $=$ & $w_2$ &  & &  & \\
+\end{tabular}
+\end{center}
 
-The exact placement of the value of $x$ depends on several key factors.   The cost of allocating storage for the temporary variables, the cost of 
-performing the additions and most importantly the cost of performing a single precision multiplication.  With a processor where single precision 
-multiplication is fast\footnote{The AMD Athlon for instance has a six cycle multiplier compared to the Intel P4 which has a 15 cycle multiplier.} the 
-cutoff point will move upwards.  Similarly with a slower processor the cutoff point will move downwards.  
+By adding the first and last equation to the equation in the middle the term $w_1$ can be isolated and all three coefficients solved for.  The simplicity
+of this system of equations has made Karatsuba fairly popular.  In fact the cutoff point is often fairly low\footnote{With LibTomMath 0.18 it is 70 and 109 for the Intel P4 and AMD Athlon respectively.}
+making it an ideal algorithm to speed up certain public key cryptosystems such as RSA and Diffie-Hellman.  It is worth noting that the point 
+$\zeta_1$ could be substituted for $-\zeta_{-1}$.  In this case the first and third row are subtracted instead of added to the second row.  
 
 \newpage\begin{figure}[!here]
 \begin{small}
@@ -2327,20 +2392,20 @@ cutoff point will move upwards.  Similarly with a slower processor the cutoff po
 \textbf{Input}.   mp\_int $a$ and mp\_int $b$ \\
 \textbf{Output}.  $c \leftarrow \vert a \vert \cdot \vert b \vert$ \\
 \hline \\
-1.  $B \leftarrow \mbox{min}(a.used, b.used)/2$ \\
-2.  Init the following mp\_int variables: $x0$, $x1$, $y0$, $y1$, $t1$, $x0y0$, $x1y1$.\\
-3.  If step 2 failed then return(\textit{MP\_MEM}). \\
+1.  Init the following mp\_int variables: $x0$, $x1$, $y0$, $y1$, $t1$, $x0y0$, $x1y1$.\\
+2.  If step 2 failed then return(\textit{MP\_MEM}). \\
 \\
 Split the input.  e.g. $a = x1 \cdot \beta^B + x0$ \\
-4.  $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{hint: use mp\_mod\_2d}) \\
+3.  $B \leftarrow \mbox{min}(a.used, b.used)/2$ \\
+4.  $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{mp\_mod\_2d}) \\
 5.  $y0 \leftarrow b \mbox{ (mod }\beta^B\mbox{)}$ \\
-6.  $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{hint: use mp\_rshd}) \\
+6.  $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{mp\_rshd}) \\
 7.  $y1 \leftarrow \lfloor b / \beta^B \rfloor$ \\
 \\
 Calculate the three products. \\
-8.  $x0y0 \leftarrow x0 \cdot y0$ (\textit{hint: use mp\_mul}) \\
+8.  $x0y0 \leftarrow x0 \cdot y0$ (\textit{mp\_mul}) \\
 9.  $x1y1 \leftarrow x1 \cdot y1$ \\
-10.  $t1 \leftarrow x1 - x0$ (\textit{hint: use mp\_sub}) \\
+10.  $t1 \leftarrow x1 - x0$ (\textit{mp\_sub}) \\
 11.  $x0 \leftarrow y1 - y0$ \\
 12.  $t1 \leftarrow t1 \cdot x0$ \\
 \\
@@ -2349,7 +2414,7 @@ Calculate the middle term. \\
 14.  $t1 \leftarrow x0 - t1$ \\
 \\
 Calculate the final product. \\
-15.  $t1 \leftarrow t1 \cdot \beta^B$ (\textit{hint: use mp\_lshd}) \\
+15.  $t1 \leftarrow t1 \cdot \beta^B$ (\textit{mp\_lshd}) \\
 16.  $x1y1 \leftarrow x1y1 \cdot \beta^{2B}$ \\
 17.  $t1 \leftarrow x0y0 + t1$ \\
 18.  $c \leftarrow t1 + x1y1$ \\
@@ -2363,85 +2428,1874 @@ Calculate the final product. \\
 \end{figure}
 
 \textbf{Algorithm mp\_karatsuba\_mul.}
+This algorithm computes the unsigned product of two inputs using the Karatsuba method.  It is loosely based on the description
+from \cite[pp. 294-295]{TAOCPV2}.  
+
+\index{radix point}
+In order to split the two inputs into their respective halves a suitable \textit{radix point} must be chosen.  The radix point chosen must
+be used for both of the inputs meaning that it must smaller than the smallest input.  Step 3 chooses the radix point $B$ as half of the 
+smallest input \textbf{used} count.  After the radix point is chosen the inputs are split into lower and upper halves.  Step 4 and 5 
+compute the lower halves.  Step 6 and 7 computer the upper halves.  
+
+After the halves have been computed the three intermediate half-size products must be computed.  Step 8 and 9 compute the trivial products
+$x0 \cdot y0$ and $x1 \cdot y1$.  The mp\_int $x0$ is used as a temporary variable after $x1 - x0$ has been computed.  By using $x0$ instead
+of an additional temporary variable the algorithm can avoid an addition memory allocation operation.
+
+The remaining steps 13 through 18 compute the Karatsuba polynomial through a variety of digit shifting and addition operations.
+
+EXAM,bn_mp_karatsuba_mul.c
+
+The new coding element in this routine that has not been seen in the previous routines yet is the usage of the goto statements.  The normal
+wisdom is that goto statements should be avoided.  This is generally true however, when every single function call can fail it makes sense
+to handle error recovery with a single piece of code.  Lines @61,if@ to @75,if@ handle initializing all of the temporary variables 
+required.  Note how each of the if statements goes to a different label in case of failure.  This allows the routine to correctly free only
+the temporaries that have been successfully allocated so far.
 
+The temporary variables are all initialized using the mp\_init\_size routine since they are expected to be large.  This saves the 
+additional reallocation that would have been necessary.  Also $x0$, $x1$, $y0$ and $y1$ have to be able to hold at least their respective
+number of digits for the next section of code.
+
+The first algebraic portion of the algorithm is to split the two inputs into their halves.  However, instead of using mp\_mod\_2d and mp\_rshd
+to extract the halves the code has been inlined.  To initialize the halves the \textbf{used} and \textbf{sign} members are copied first.  The first
+for loop on line @98,for@ copies the lower halves.  Since they are both the same magnitude it is simpler to calculate both lower halves in a single
+loop.  The for loop on lines @104,for@ and @109,for@ calculate the upper halves $x1$ and $y1$ respectively.
+
+By inlining the calculation of the halves the Karatsuba multiplier has a slightly lower overhead.  As a result it can be used for smaller 
+inputs.
+
+When line @152,err@ is reached the algorithm has completed succesfully.  The ``error status'' variable $err$ is set to \textbf{MP\_OKAY} so that
+the same code that handles errors can be used to clear the temporary variables and return.  
+
+\subsection{Toom-Cook $3$-Way Multiplication}
+Toom-Cook $3$-Way multiplication \cite{TOOM} is essentially the polynomial basis algorithm for $n = 3$ except that the points  are 
+chosen such that $\zeta$ is easy to compute and the resulting system of equations easy to reduce.  In this algorithm the points $\zeta_{0}$, 
+$16 \cdot \zeta_{1 \over 2}$, $\zeta_1$, $\zeta_2$ and $\zeta_{\infty}$ make up the five requires points to solve for the coefficients of the
+product.  
+
+At first glance the five coefficents are relatively efficient to compute with the exception of $16 \cdot \zeta{1 \over 2}$.  This coefficient
+is related to $\zeta_2 = (4a_2 + 2a_1 + a_0)(4b_2 + 2b_1 + b_0)$ in that the coefficients  of two terms are reversed (\textit{or mirrored}).  
+Simply put $16 \cdot \zeta{1 \over 2} = (a_2 + 2a_1 + 4a_0)(b_2 + 2b_1 + 4b_0)$.  
+
+With the five relations that Toom has chosen the following system of equations is formed.
+
+\begin{center}
+\begin{tabular}{rcrcrcrcrcr}
+$\zeta_0$                    & $=$ & $0w_4$ & $+$ & $0w_3$ & $+$ & $0w_2$ & $+$ & $0w_1$ & $+$ & $1w_0$  \\
+$16 \cdot \zeta_{1 \over 2}$ & $=$ & $1w_4$ & $+$ & $2w_3$ & $+$ & $4w_2$ & $+$ & $8w_1$ & $+$ & $16w_0$  \\
+$\zeta_1$                    & $=$ & $1w_4$ & $+$ & $1w_3$ & $+$ & $1w_2$ & $+$ & $1w_1$ & $+$ & $1w_0$  \\
+$\zeta_2$                    & $=$ & $16w_4$ & $+$ & $8w_3$ & $+$ & $4w_2$ & $+$ & $2w_1$ & $+$ & $1w_0$  \\
+$\zeta_{\infty}$             & $=$ & $1w_4$ & $+$ & $0w_3$ & $+$ & $0w_2$ & $+$ & $0w_1$ & $+$ & $0w_0$  \\
+\end{tabular}
+\end{center}
+
+A trivial solution to this matrix requires $12$ subtractions, two multiplications by a small power of two, two divisions by a small power
+of two, two divisions by three and one multiplication by three.  All of these $19$ sub-operations require less than quadratic time meaning that
+the algorithm overall can be faster than a baseline multiplication.  However, the greater complexity of this algorithm places the cutoff point
+(\textbf{TOOM\_MUL\_CUTOFF}) where Toom-Cook becomes the most efficient algorithm very much higher above the Karatsuba cutoff point.  
+
+\subsection{Signed Multiplication}
+Now that algorithms to handle multiplications of every useful dimensions has been developed a rather simple finishing touch is required.  So far all
+of the multiplication algorithms have been unsigned which leaves only a signed multiplication algorithm to be established.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_mul}. \\
+\textbf{Input}.   mp\_int $a$ and mp\_int $b$ \\
+\textbf{Output}.  $c \leftarrow a \cdot b$ \\
+\hline \\
+1.  If $a.sign = b.sign$ then \\
+\hspace{3mm}1.1  $sign = MP\_ZPOS$ \\
+2.  else \\
+\hspace{3mm}2.1  $sign = MP\_ZNEG$ \\
+3.  If min$(a.used, b.used) \ge TOOM\_MUL\_CUTOFF$ then  \\
+\hspace{3mm}3.1  $c \leftarrow a \cdot b$ using algorithm mp\_toom\_mul \\
+4.  else if min$(a.used, b.used) \ge KARATSUBA\_MUL\_CUTOFF$ then \\
+\hspace{3mm}4.1  $c \leftarrow a \cdot b$ using algorithm mp\_karatsuba\_mul \\
+5.  else \\
+\hspace{3mm}5.1  $digs \leftarrow a.used + b.used + 1$ \\
+\hspace{3mm}5.2  If $digs < MP\_ARRAY$ and min$(a.used, b.used) \le \delta$ then \\
+\hspace{6mm}5.2.1  $c \leftarrow a \cdot b \mbox{ (mod }\beta^{digs}\mbox{)}$ using algorithm fast\_s\_mp\_mul\_digs.  \\
+\hspace{3mm}5.3  else \\
+\hspace{6mm}5.3.1  $c \leftarrow a \cdot b \mbox{ (mod }\beta^{digs}\mbox{)}$ using algorithm s\_mp\_mul\_digs.  \\
+6.  $c.sign \leftarrow sign$ \\
+7.  Return the result of the unsigned multiplication performed. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_mul}
+\end{figure}
+
+\textbf{Algorithm mp\_mul.}
+This algorithm performs the signed multiplication of two inputs.  It will make use of any of the three unsigned multiplication algorithms 
+available when the input is of appropriate size.  The \textbf{sign} of the result is not set until the end of the algorithm since algorithm
+s\_mp\_mul\_digs will clear it.  
+
+EXAM,bn_mp_mul.c
+
+The implementation is rather simplistic and is not particularly noteworthy.  Line @22,?@ computes the sign of the result using the ``?'' 
+operator from the C programming language.  Line @37,<<@ computes $\delta$ using the fact that $1 << k$ is equal to $2^k$.  
 
 \section{Squaring}
+
+Squaring is a special case of multiplication where both multiplicands are equal.  At first it may seem like there is no significant optimization
+available but in fact there is.  Consider the multiplication of $576$ against $241$.  In total there will be nine single precision multiplications
+performed which are $1\cdot 6$, $1 \cdot 7$, $1 \cdot 5$, $4 \cdot 6$, $4 \cdot 7$, $4 \cdot 5$, $2 \cdot  6$, $2 \cdot 7$ and $2 \cdot 5$.  Now consider 
+the multiplication of $123$ against $123$.  The nine products are $3 \cdot 3$, $3 \cdot 2$, $3 \cdot 1$, $2 \cdot 3$, $2 \cdot 2$, $2 \cdot 1$, 
+$1 \cdot 3$, $1 \cdot 2$ and $1 \cdot 1$.  On closer inspection some of the products are equivalent.  For example, $3 \cdot 2 = 2 \cdot 3$ 
+and $3 \cdot 1 = 1 \cdot 3$. 
+
+For any $n$-digit input there are ${{\left (n^2 + n \right)}\over 2}$ possible unique single precision multiplications required.  The following
+diagram demonstrates the operations required.
+
+\begin{figure}[here]
+\begin{center}
+\begin{tabular}{ccccc|c}
+&&1&2&3&\\
+$\times$ &&1&2&3&\\
+\hline && $3 \cdot 1$ & $3 \cdot 2$ & $3 \cdot 3$ & Row 0\\
+       & $2 \cdot 1$  & $2 \cdot 2$ & $2 \cdot 3$ && Row 1 \\
+         $1 \cdot 1$  & $1 \cdot 2$ & $1 \cdot 3$ &&& Row 2 \\
+\end{tabular}
+\end{center}
+\caption{Squaring Optimization Diagram}
+\end{figure}
+
+MARK,SQUARE
+Starting from zero and numbering the columns from right to left a very simple pattern becomes obvious.  For the purposes of this discussion let $x$
+represent the number being squared.  The first observation is that in row $k$ the $2k$'th column of the product has a $\left (x_k \right)^2$ term in it.  
+
+The second observation is that every column $j$ in row $k$ where $j \ne 2k$ is part of a double product.  Every odd column is made up entirely of 
+double products.  In fact every column is made up of double products and at most one square (\textit{see the exercise section}).  
+
+The third and final observation is that for row $k$ the first unique non-square term occurs at column $2k + 1$.  For example, on row $1$ of the 
+previous squaring, column one is part of the double product with column one from row zero. Column two of row one is a square and column three is
+the first unique column.
+
 \subsection{The Baseline Squaring Algorithm}
+The baseline squaring algorithm is meant to be a catch-all squaring algorithm.  It will handle any of the input sizes that the faster routines
+will not handle.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{s\_mp\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+1.  Init a temporary mp\_int of at least $2 \cdot a.used +1$ digits.  (\textit{mp\_init\_size}) \\
+2.  If step 1 failed return(\textit{MP\_MEM}) \\
+3.  $t.used \leftarrow 2 \cdot a.used + 1$ \\
+4.  For $ix$ from 0 to $a.used - 1$ do \\
+\hspace{3mm}Calculate the square. \\
+\hspace{3mm}4.1  $\hat r \leftarrow t_{2ix} + \left (a_{ix} \right )^2$ \\
+\hspace{3mm}4.2  $t_{2ix} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}Calculate the double products after the square. \\
+\hspace{3mm}4.3  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+\hspace{3mm}4.4  For $iy$ from $ix + 1$ to $a.used - 1$ do \\
+\hspace{6mm}4.4.1  $\hat r \leftarrow 2 \cdot a_{ix}a_{iy} + t_{ix + iy} + u$ \\
+\hspace{6mm}4.4.2  $t_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{6mm}4.4.3  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+\hspace{3mm}Set the last carry. \\
+\hspace{3mm}4.5  While $u > 0$ do \\
+\hspace{6mm}4.5.1  $iy \leftarrow iy + 1$ \\
+\hspace{6mm}4.5.2  $\hat r \leftarrow t_{ix + iy} + u$ \\
+\hspace{6mm}4.5.3  $t_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{6mm}4.5.4  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+5.  Clamp excess digits of $t$.  (\textit{mp\_clamp}) \\
+6.  Exchange $b$ and $t$. \\
+7.  Clear $t$ (\textit{mp\_clear}) \\
+8.  Return(\textit{MP\_OKAY}) \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm s\_mp\_sqr}
+\end{figure}
+
+\textbf{Algorithm s\_mp\_sqr.}
+This algorithm computes the square of an input using the three observations on squaring.  It is based fairly faithfully on  algorithm 14.16 of 
+\cite[pp.596-597]{HAC}.  Similar to algorithm s\_mp\_mul\_digs a temporary mp\_int is allocated to hold the result of the squaring.  This allows the 
+destination mp\_int to be the same as the source mp\_int without losing information part way through the squaring.
+
+The outer loop of this algorithm begins on step 4. It is best to think of the outer loop as walking down the rows of the partial results while
+the inner loop computes the columns of the partial result.  Step 4.1 and 4.2 compute the square term for each row while step 4.3 and 4.4 propagate
+the carry and compute the double products.  
+
+The requirement that a mp\_word be able to represent the range $0 \le x < 2 \beta^2$ arises from this
+very algorithm.  The product $a_{ix}a_{iy}$ will lie in the range $0 \le x \le \beta^2 - 2\beta + 1$ which is obviously less than $\beta^2$ meaning that
+when it is multiply by two it can be represented by a mp\_word properly.
+
+Similar to algorithm s\_mp\_mul\_digs after every pass of the inner loop the destination is correctly set to the sum of all of the partial 
+results calculated so far.  This involves expensive carry propagation which will be eliminated shortly.  
+
+EXAM,bn_s_mp_sqr.c
+
+Inside the outer loop (\textit{see line @32,for@}) the square term is calculated on line @35,r =@.  Line @42,>>@ extracts the carry from the square
+term.  Aliases for $a_{ix}$ and $t_{ix+iy}$ are initialized on lines @45,tmpx@ and @48,tmpt@ respectively.  The doubling is performed using two
+additions (\textit{see line @57,r + r@}) since it is usually faster than shifting if not at least as fast.  
+
 \subsection{Faster Squaring by the ``Comba'' Method}
+A major drawback to the baseline method is the requirement for single precision shifting inside the $O(n^2)$ work level.  Squaring has an additional
+drawback that it must double the product inside the inner loop as well.  As for multiplication the Comba technique can be used to eliminate these
+performance hazards.
+
+The first obvious solution is to make an array of mp\_words which will hold all of the columns.  This will indeed eliminate all of the carry
+propagation operations from the inner loop.  However, the inner product must still be doubled $O(n^2)$ times.  The solution stems from the simple fact
+that $2a + 2b + 2c = 2(a + b + c)$.  That is the sum of all of the double products is equal to double the sum of all the products.  For example,
+$ab + ba + ac + ca = 2ab + 2ac = 2(ab + ac)$.  
+
+However, we cannot simply double all of the columns since the squares appear only once per row.  The most practical solution is to have two mp\_word
+arrays.  One array will hold the squares and the other array will hold the double products.  With both arrays the doubling and carry propagation can be 
+moved to a $O(n)$ work level outside the $O(n^2)$ level.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{fast\_s\_mp\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+Place two arrays of \textbf{MP\_WARRAY} mp\_words named $\hat W$ and $\hat {X}$ on the stack. \\
+1.  If $b.alloc < 2a.used + 1$ then grow $b$ to $2a.used + 1$ digits.  (\textit{mp\_grow}). \\
+2.  If step 1 failed return(\textit{MP\_MEM}). \\
+3.  for $ix$ from $0$ to $2a.used + 1$ do \\
+\hspace{3mm}3.1  $\hat W_{ix} \leftarrow 0$ \\
+\hspace{3mm}3.2  $\hat {X}_{ix} \leftarrow 0$ \\
+4.  for $ix$ from $0$ to $a.used - 1$ do \\
+\hspace{3mm}Compute the square.\\
+\hspace{3mm}4.1  $\hat {X}_{ix+ix} \leftarrow \left ( a_ix \right )^2$ \\
+\hspace{3mm}Compute the double products.\\
+\hspace{3mm}4.2  for $iy$ from $ix + 1$ to $a.used - 1$ do \\
+\hspace{6mm}4.2.1  $\hat W_{ix+iy} \leftarrow \hat W_{ix+iy} + a_{ix}a_{iy}$ \\
+5.  $oldused \leftarrow b.used$ \\
+6.  $b.used \leftarrow 2a.used + 1$ \\
+Double the products and propagate the carries simultaneously. \\
+7.  $\hat W_0 \leftarrow 2 \hat W_0 + \hat {X}_0$ \\
+8.  for $ix$ from $1$ to $2a.used$ do \\
+\hspace{3mm}8.1 $\hat W_{ix} \leftarrow 2 \hat W_{ix} + \hat {X}_{ix}$ \\
+\hspace{3mm}8.2 $\hat W_{ix} \leftarrow \hat W_{ix} + \lfloor \hat W_{ix - 1} / \beta \rfloor$ \\
+\hspace{3mm}8.3 $b_{ix-1} \leftarrow W_{ix-1} \mbox{ (mod }\beta\mbox{)}$ \\
+9.  $b_{2a.used} \leftarrow \hat W_{2a.used} \mbox{ (mod }\beta\mbox{)}$ \\
+10.  if $2a.used + 1 < oldused$ then do \\
+\hspace{3mm}10.1  for $ix$ from $2a.used + 1$ to $oldused$ do \\
+\hspace{6mm}10.1.1  $b_{ix} \leftarrow 0$ \\
+11.  Clamp excess digits from $b$.  (\textit{mp\_clamp}) \\
+12.  Return(\textit{MP\_OKAY}). \\ 
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm fast\_s\_mp\_sqr}
+\end{figure}
+
+\textbf{Algorithm fast\_s\_mp\_sqr.}
+This algorithm computes the square of an input using the Comba technique.  It is designed to be a replacement for algorithm s\_mp\_sqr when
+the amount of input digits is less than \textbf{MP\_WARRAY} and less than $\delta \over 2$.  
+
+This routine requires two arrays of mp\_words to be placed on the stack.  The first array $\hat W$ will hold the double products and the second
+array $\hat X$ will hold the squares.  Though only at most $MP\_WARRAY \over 2$ words of $\hat X$ are used it has proven faster on most 
+processors to simply make it a full size array.
+
+The loop on step 3 will zero the two arrays to prepare them for the squaring step.  Step 4.1 computes the squares of the product.  Note how 
+it simply assigns the value into the $\hat X$ array.  The nested loop on step 4.2 computes the doubles of the products.  In actuality that loop
+computes the sum of the products for each column.  They are not doubled until later.
+
+After the squaring loop the products stored in $\hat W$ musted be doubled and the carries propagated forwards.  It makes sense to do both
+operations at the same time.  The expression $\hat W_{ix} \leftarrow 2 \hat W_{ix} + \hat {X}_{ix}$ computes the sum of the double product and the
+squares in place.  
+
+EXAM,bn_fast_s_mp_sqr.c
+
+-- Write something deep and insightful later, Tom.
+
+\subsection{Polynomial Basis Squaring}
+The same algorithm that performs optimal polynomial basis multiplication can be used to perform polynomial basis squaring.  The minor exception
+is that $\zeta_y = f(y) \cdot g(y)$ is actually equivalent to $\zeta_y = f(y)^2$ since $f(y) = g(y)$.  That is instead of performing $2n + 1$
+multiplications to find the $\zeta$ relations squaring operations are performed instead.  
+
 \subsection{Karatsuba Squaring}
-\section{Tuning Algorithms}
-\subsection{How to Tune Karatsuba Algorithms}
+Let $f(x) = ax + b$ represent the polynomial basis representation of a number to square.  
+Let $h(x) = \left ( f(x) \right )^2$ represent the square of the polynomial.  The Karatsuba equation can be modified to square a 
+number with the following equation.
 
-\chapter{Modular Reductions}
-\section{Basics of Modular Reduction}
-\section{The Barrett Reduction}
-\section{The Montgomery Reduction}
-\subsection{Faster ``Comba'' Montgomery Reduction}
-\subsection{Example Montgomery Algorithms}
-\section{The Diminished Radix Algorithm}
-\section{Algorithm Comparison}
+\begin{equation}
+h(x) = a^2x^2 + \left (a^2 + b^2 - (a - b)^2 \right )x + b^2
+\end{equation}
 
-\chapter{Exponentiation}
-\section{Single Digit Exponentiation}
-\section{Modular Exponentiation}
-\subsection{General Case}
-\subsection{Odd or Diminished Radix Moduli}
-\section{Quick Power of Two}
+Upon closer inspection this equation only requires the calculation of three half-sized squares: $a^2$, $b^2$ and $(a - b)^2$.  As in 
+Karatsuba multiplication this algorithm can be applied recursively on the input and will achieve an asymptotic running time of 
+$O \left ( n^{lg(3)} \right )$.
 
-\chapter{Higher Level Algorithms}
-\section{Integer Division with Remainder}
-\section{Single Digit Helpers}
-\subsection{Single Digit Addition}
-\subsection{Single Digit Subtraction}
-\subsection{Single Digit Multiplication}
-\subsection{Single Digit Division}
-\subsection{Single Digit Modulo}
-\subsection{Single Digit Root Extraction}
-\section{Random Number Generation}
-\section{Formatted Output}
-\subsection{Getting The Output Size}
-\subsection{Generating Radix-n Output}
-\subsection{Reading Radix-n Input}
-\section{Unformatted Output}
-\subsection{Getting The Output Size}
-\subsection{Generating Output}
-\subsection{Reading Input}
+If the asymptotic time of Karatsuba squaring and multiplication is the same why not simply use the multiplication algorithm instead?  The answer
+to this question arises from the cutoff point for squaring.  As in multiplication there exists a cutoff point at which the time required for a 
+Comba based squaring and a Karatsuba based squaring meet.  Due to the overhead inherent in the Karatsuba method the cutoff point is fairly 
+high.  For example, on an Athlon processor with $\beta = 2^{28}$ the cutoff point is around 127 digits.  
 
-\chapter{Number Theoretic Algorithms}
-\section{Greatest Common Divisor}
-\section{Least Common Multiple}
-\section{Jacobi Symbol Computation}
-\section{Modular Inverse}
-\subsection{General Case}
-\subsection{Odd Moduli}
-\section{Primality Tests}
-\subsection{Trial Division}
-\subsection{The Fermat Test}
-\subsection{The Miller-Rabin Test}
-\subsection{Primality Test in a Bottle}
-\subsection{The Next Prime}
-\section{Root Extraction}
+Consider squaring a 200 digit number with this technique.  It will be split into two 100 digit halves which are subsequently squared.  
+The 100 digit numbers will not be squared using Karatsuba but instead the faster Comba based squaring algorithm.  If Karatsuba multiplication
+were used instead the 100 digit numbers would be squared with a slower Comba based multiplication.  
 
-\backmatter
-\appendix
-\begin{thebibliography}{ABCDEF}
-\bibitem[1]{TAOCPV2}
-Donald Knuth, \textit{The Art of Computer Programming}, Third Edition, Volume Two, Seminumerical Algorithms, Addison-Wesley, 1998
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_karatsuba\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+1.  Initialize the following temporary mp\_ints:  $x0$, $x1$, $t1$, $t2$, $x0x0$ and $x1x1$. \\
+2.  If any of the initializations on step 1 failed return(\textit{MP\_MEM}). \\
+\\
+Split the input.  e.g. $a = x1\beta^B + x0$ \\
+3.  $B \leftarrow a.used / 2$ \\
+4.  $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{mp\_mod\_2d}) \\
+5.  $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{mp\_lshd}) \\
+\\
+Calculate the three squares. \\
+6.  $x0x0 \leftarrow x0^2$ (\textit{mp\_sqr}) \\
+7.  $x1x1 \leftarrow x1^2$ \\
+8.  $t1 \leftarrow x1 - x0$ (\textit{mp\_sub}) \\
+9.  $t1 \leftarrow t1^2$ \\
+\\
+Compute the middle term. \\
+10.  $t2 \leftarrow x0x0 + x1x1$ (\textit{s\_mp\_add}) \\
+11.  $t1 \leftarrow t2 - t1$ \\
+\\
+Compute final product. \\
+12.  $t1 \leftarrow t1\beta^B$ (\textit{mp\_lshd}) \\
+13.  $x1x1 \leftarrow x1x1\beta^{2B}$ \\
+14.  $t1 \leftarrow t1 + x0x0$ \\
+15.  $b \leftarrow t1 + x1x1$ \\
+16.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_karatsuba\_sqr}
+\end{figure}
 
-\bibitem[2]{HAC}
-A. Menezes, P. van Oorschot, S. Vanstone, \textit{Handbook of Applied Cryptography}, CRC Press, 1996
+\textbf{Algorithm mp\_karatsuba\_sqr.}
+This algorithm computes the square of an input $a$ using the Karatsuba technique.  This algorithm is very much similar to the Karatsuba based
+multiplication algorithm.  
 
-\bibitem[3]{ROSE}
-Michael Rosing, \textit{Implementing Elliptic Curve Cryptography}, Manning Publications, 1999
+The radix point for squaring is simply the placed above the median of the digits.  Step 3, 4 and 5 compute the two halves required using $B$
+as the radix point.  The first two squares in steps 6 and 7 are rather straightforward while the last square is in a more compact form.
 
-\bibitem[4]{COMBA}
-Paul G. Comba, \textit{Exponentiation Cryptosystems on the IBM PC}. IBM Systems Journal 29(4): 526-538 (1990)
+By expanding $\left (x1 - x0 \right )^2$ the $x1^2$ and $x0^2$ terms in the middle disappear, that is $x1^2 + x0^2 - (x1 - x0)^2 = 2 \cdot x0 \cdot x1$.
+Now if $5n$ single precision additions and a squaring of $n$-digits is faster than multiplying two $n$-digit numbers and doubling then
+this method is faster.  Assuming no further recursions occur the difference can be estimated.
 
-\bibitem[5]{KARA}
-A. Karatsuba, Doklay Akad. Nauk SSSR 145 (1962), pp.293-294
+Let $p$ represent the cost of a single precision addition and $q$ the cost of a single precision multiplication both in terms of time\footnote{Or
+machine clock cycles.}.  The question reduces to whether the following equation is true or not.
 
-\bibitem[6]{KARAP}
-Andre Weimerskirch and Christof Paar, \textit{Generalizations of the Karatsuba Algorithm for Polynomial Multiplication}, Submitted to Design, Codes and Cryptography, March 2002
+\begin{equation}
+5np +{{q(n^2 + n)} \over 2} \le pn + qn^2
+\end{equation}
+
+For example, on an AMD Athlon processor $p = {1 \over 3}$ and $q = 6$.  This implies that the following inequality should hold.
+\begin{center}
+\begin{tabular}{rcl}
+$5n + 3n^2 + 3n$     & $<$ & ${n \over 3} + 6n^2$ \\
+${25 \over 3} + 3n$  & $<$ & ${1 \over 3} + 6n$ \\
+${25 \over 3}$       & $<$ & $3n$ \\
+${25 \over 9}$       & $<$ & $n$ \\
+\end{tabular}
+\end{center}
+
+This results in a cutoff point around $n = 3$.  As a consequence it is actually faster to compute the middle term the ``long way'' on processors
+where multiplication is substantially slower\footnote{On the Athlon there is a 1:17 ratio between clock cycles for addition and multiplication.  On
+the Intel P4 processor this ratio is 1:29 making this method even more beneficial.  The only common exception is the ARMv4 processor which has a
+ratio of 1:7.  } than simpler operations such as addition.  
+
+EXAM,bn_mp_karatsuba_sqr.c
+
+This implementation is largely based on the implementation of algorithm mp\_karatsuba\_mul.  It uses the same inline style to copy and 
+shift the input into the two halves.  The loop from line @54,{@ to line @70,}@ has been modified since only one input exists.  The \textbf{used}
+count of both $x0$ and $x1$ is fixed up and $x0$ is clamped before the calculations begin.  At this point $x1$ and $x0$ are valid equivalents
+to the respective halves as if mp\_rshd and mp\_mod\_2d had been used.  
+
+By inlining the copy and shift operations the cutoff point for Karatsuba multiplication can be lowered.  On the Athlon the cutoff point
+is exactly at the point where Comba squaring can no longer be used (\textit{128 digits}).  On slower processors such as the Intel P4
+it is actually below the Comba limit (\textit{at 110 digits}).
+
+This routine uses the same error trap coding style as mp\_karatsuba\_sqr.  As the temporary variables are initialized errors are redirected to
+the error trap higher up.  If the algorithm completes without error the error code is set to \textbf{MP\_OKAY} and the error traps are 
+executed.
+
+\textit{Last paragraph sucks.  re-write! -- Tom}
+
+\subsection{Toom-Cook Squaring}
+The Toom-Cook squaring algorithm mp\_toom\_sqr is heavily based on the algorithm mp\_toom\_mul with the minor exception noted.  The reader is 
+encouraged to read the description of the latter algorithm and try to derive their own Toom-Cook squaring algorithm.  
+
+\subsection{Generic Squaring}
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+1.  If $a.used \ge TOOM\_SQR\_CUTOFF$ then  \\
+\hspace{3mm}1.1  $b \leftarrow a^2$ using algorithm mp\_toom\_sqr \\
+2.  else if $a.used \ge KARATSUBA\_SQR\_CUTOFF$ then \\
+\hspace{3mm}2.1  $b \leftarrow a^2$ using algorithm mp\_karatsuba\_sqr \\
+3.  else \\
+\hspace{3mm}3.1  $digs \leftarrow a.used + b.used + 1$ \\
+\hspace{3mm}3.2  If $digs < MP\_ARRAY$ and $a.used \le \delta$ then \\
+\hspace{6mm}3.2.1  $b \leftarrow a^2$ using algorithm fast\_s\_mp\_sqr.  \\
+\hspace{3mm}3.3  else \\
+\hspace{6mm}3.3.1  $b \leftarrow a^2$ using algorithm s\_mp\_sqr.  \\
+4.  $b.sign \leftarrow MP\_ZPOS$ \\
+5.  Return the result of the unsigned squaring performed. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_sqr}
+\end{figure}
+
+\textbf{Algorithm mp\_sqr.}
+This algorithm computes the square of the input using one of four different algorithms.  If the input is very large and has at least
+\textbf{TOOM\_SQR\_CUTOFF} or \textbf{KARATSUBA\_SQR\_CUTOFF} digits then either the Toom-Cook or the Karatsuba Squaring algorithm is used.  If
+neither of the polynomial basis algorithms should be used then either the Comba or baseline algorithm is used.  
+
+EXAM,bn_mp_sqr.c
+
+\section*{Exercises}
+\begin{tabular}{cl}
+$\left [ 3 \right ] $ & Devise an efficient algorithm for selection of the radix point to handle inputs \\
+                      & that have different number of digits in Karatsuba multiplication. \\
+                      & \\
+$\left [ 3 \right ] $ & In ~SQUARE~ the fact that every column of a squaring is made up \\
+                      & of double products and at most one square is stated.  Prove this statement. \\
+                      & \\                      
+$\left [ 2 \right ] $ & In the Comba squaring algorithm half of the $\hat X$ variables are not used. \\
+                      & Revise algorithm fast\_s\_mp\_sqr to shrink the $\hat X$ array. \\
+                      & \\
+$\left [ 3 \right ] $ & Prove the equation for Karatsuba squaring. \\
+                      & \\
+$\left [ 1 \right ] $ & Prove that Karatsuba squaring requires $O \left (n^{lg(3)} \right )$ time. \\
+                      & \\ 
+$\left [ 2 \right ] $ & Determine the minimal ratio between addition and multiplication clock cycles \\
+                      & required for equation $6.7$ to be true.  \\
+                      & \\
+\end{tabular}
+
+\chapter{Modular Reduction}
+MARK,REDUCTION
+\section{Basics of Modular Reduction}
+\index{modular residue}
+Modular reduction is an operation that arises quite often within public key cryptography algorithms.  A number is said to be reduced modulo another
+number by finding the remainder of division.  If an integer $a$ is reduced modulo $b$ that is to solve the equation $a = bq + p$ then $p$ is the 
+result.  To phrase that another way ``$p$ is congruent to $a$ modulo $b$'' which is also written as $p \equiv a \mbox{ (mod }b\mbox{)}$.  In
+other vernacular $p$ is known as the ``modular residue'' which leads to ``quadratic residue''\footnote{That's fancy talk for $b \equiv a^2 \mbox{ (mod }p\mbox{)}$.} and
+other forms of residues.  
+
+\index{modulus}
+Modular reductions are normally used to form finite groups such as fields and rings.  For example, in the RSA public key algorithm \cite{RSAPAPER} 
+two private primes $p$ and $q$ are chosen which when multiplied $n = pq$ forms a composite modulus.  When operations such as multiplication and
+squaring are performed on units of the ring $\Z_n$ a finite multiplicative sub-group is formed.  This sub-group is the group used to perform RSA
+operations.  Do not worry to much about how RSA works as it is not important for this discussion.   
+
+The most common usage for performance driven modular reductions is in modular exponentiation algorithms.  That is to compute 
+$d = a^b \mbox{ (mod }c\mbox{)}$ as fast as possible.  As will be discussed in the subsequent chapter there exists fast algorithms for computing
+modular exponentiations without having to perform (\textit{in this example}) $b$ multiplications.  These algorithms will produce partial
+results in the range $0 \le x < c^2$ which can be taken advantage of.  
+
+The obvious line of thinking is to use an integer division routine and just extract the remainder.  While this is equivalent to finding the 
+modular residue it turns out that the limited range of the input can be exploited to create several efficient algorithms.  
+
+\section{The Barrett Reduction}
+The Barrett reduction algorithm \cite{BARRETT} was inspired by fast division algorithms which multiply by the reciprocal to emulate
+division.  Barretts observation was that the residue $c$ of $a$ modulo $b$ is equal to 
+
+\begin{equation}
+c = a - b \cdot \lfloor a/b \rfloor
+\end{equation}
+
+Since algorithms such as modular reduction would be using the same modulus extensively, using typical DSP intuition the next step would be to 
+replace $a/b$ with a multiplication by the reciprocal.  However, DSP intuition on its own will not work as these numbers are considerably
+larger than the precision of common DSP floating point data types.  It would take another common optimization to optimize the algorithm.
+
+\subsection{Fixed Point Arithmetic}
+The trick used to optimize the above equation is based on a technique of emulating floating point data types with fixed precision integers.  Fixed
+point arithmetic would be vastly popularlized in the mid 1990s for bringing 3d-games to the mass market.  The idea is to take a normal $k$-bit 
+integer data type and break it into $p$-bit integer and a $q$-bit fraction part (\textit{where $p+q = k$}).  
+
+In this system a $k$-bit integer $n$ would actually represent $n/2^q$.  For example, with $q = 4$ the integer $n = 37$ would actually represent the
+value $2.3125$.  To multiply two fixed point numbers the integers are multiplied using traditional arithmetic and subsequently normalized. For example, 
+with $q = 4$ to multiply the integers $9$ and $5$ they must be converted to fixed point first by multiplying by $2^q$.  Let $a = 9(2^q)$ 
+represent the fixed point representation of $9$ and $b = 5(2^q)$ represent the fixed point representation of $5$.  The product $ab$ is equal to
+$45(2^{2q})$ which when normalized produces $45(2^q)$.  
+
+Using fixed point arithmetic division can be easily achieved by multiplying by the reciprocal.  If $2^q$ is equivalent to one than $2^q/b$ is 
+equivalent to $1/b$ using real arithmetic.  Using this fact dividing an integer $a$ by another integer $b$ can be achieved with the following
+expression.
+
+\begin{equation}
+\lfloor (a \cdot (\lfloor 2^q / b \rfloor))/2^q \rfloor
+\end{equation}
+
+The precision of the division is proportional to the value of $q$.  If the divisor $b$ is used frequently as is the case with 
+modular exponentiation pre-computing $2^q/b$ will allow a division to be performed with a multiplication and a right shift.  Both operations
+are considerably faster than division on most processors.  
+
+Consider dividing $19$ by $5$.  The correct result is $\lfloor 19/5 \rfloor = 3$.  With $q = 3$ the reciprocal is $\lfloor 2^q/5 \rfloor = 1$ which
+leads to a product of $19$ which when divided by $2^q$ produces $2$.  However, with $q = 4$ the reciprocal is $\lfloor 2^q/5 \rfloor = 3$ and
+the result of the emulated division is $\lfloor 3 \cdot 19 / 2^q \rfloor = 3$ which is correct.  
+
+Plugging this form of divison into the original equation the following modular residue equation arises.
+
+\begin{equation}
+c = a - b \cdot \lfloor (a \cdot (\lfloor 2^q / b \rfloor))/2^q \rfloor
+\end{equation}
+
+Using the notation from \cite{BARRETT} the value of $\lfloor 2^q / b \rfloor$ will be represented by the $\mu$ symbol.  Using the $\mu$
+variable also helps re-inforce the idea that it is meant to be computed once and re-used.
+
+\begin{equation}
+c = a - b \cdot \lfloor (a \cdot \mu)/2^q \rfloor
+\end{equation}
+
+Provided that $2^q > b^2$ this algorithm will produce a quotient that is either exactly correct or off by a value of one.  Let $n$ represent
+the number of digits in $b$.  This algorithm requires approximately $2n^2$ single precision multiplications to produce the quotient and 
+another $n^2$ single precision multiplications to find the residue.  In total $3n^2$ single precision multiplications are required to 
+reduce the number.  
+
+For example, if $b = 1179677$ and $q = 41$ ($2^q > b^2$), then the reciprocal $\mu$ is equal to $\lfloor 2^q / b \rfloor = 1864089$.  Consider reducing
+$a = 180388626447$ modulo $b$ using the above reduction equation.  Using long division the quotient $\lfloor a/b \rfloor$ is equal
+to the quotient found using the fixed point method.  In this case the quotient is $\lfloor (a \cdot \mu)/2^q \rfloor = 152913$ and can
+produce the modular residue $a - 152913b = 677346$.
+
+\subsection{Choosing a Radix Point}
+Using the fixed point representation a modular reduction can be performed with $3n^2$ single precision multiplications.  If that were the best
+that could be achieved a full division might as well be used in its place.  The key to optimizing the reduction is to reduce the precision of
+the initial multiplication that finds the quotient.  
+
+Let $a$ represent the number of which the residue is sought.  Let $b$ represent the modulus used to find the residue.  Let $m$ represent
+the number of digits in $b$.  For the purposes of this discussion we will assume that the number of digits in $a$ is $2m$.  Dividing $a$ by 
+$b$ is the same as dividing a $2m$ digit integer by a $m$ digit integer.  Digits below the $m - 1$'th digit of $a$ will contribute at most a value
+of $1$ to the quotient because $\beta^k < b$ for any $0 \le k \le m - 1$.  
+
+Since those digits do not contribute much to the quotient the observation is that they might as well be zero.  However, if the digits 
+``might as well be zero'' they might as well not be there in the first place.  Let $q_0 = \lfloor a/\beta^{m-1} \rfloor$ represent the input
+with the zeroes trimmed.  Now the modular reduction is trimmed to the almost equivalent equation
+
+\begin{equation}
+c = a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor
+\end{equation}
+
+Notice how the original divisor $2^q$ has been replaced with $\beta^{m+1}$. Also note how the exponent on the divisor $m+1$ when added to the amount $q_0$
+was shifted by ($m-1$) equals $2m$.  If the optimization had not been performed the divisor would have the exponent $2m$ so in the end the exponents
+do ``add up''. By using whole digits the algorithm is much faster since shifting digits is typically slower than simply copying them.  Using the 
+above equation the quotient $\lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ can be off from the true quotient by at most two implying that 
+$0 \le a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor < 3b$.  By first subtracting $b$ times the quotient and then conditionally 
+subtracting $b$ once or twice the residue is found.
+
+The quotient is now found using $(m + 1)(m) = m^2 + m$ single precision multiplications and the residue with an additional $m^2$ single
+precision multiplications.  In total $2m^2 + m$ single precision multiplications are required which is considerably faster than the original
+attempt.
+
+For example, let $\beta = 10$ represent the radix of the digits.  Let $b = 9999$ represent the modulus which implies $m = 4$. Let $a = 99929878$ 
+represent the value of which the residue is desired.  In this case $q = 10$ which means that $\mu = \lfloor \beta^{2m}/b \rfloor = 10001$.  
+With this optimization the multiplicand for the quotient is $q_0 = \lfloor a / \beta^{m - 1} \rfloor = 99929$.  The quotient is then 
+$\lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor = 9993$.  Subtracting $9993b$ from $a$ and the correct residue $9871 \equiv a \mbox{ (mod }b\mbox{)}$ 
+is found.  
+
+\subsection{Trimming the Quotient}
+So far the reduction algorithm has been optimized from $3m^2$ single precision multiplications down to $2m^2 + m$ single precision multiplications.  As 
+it stands now the algorithm is already fairly fast compared to a full integer division algorithm.  However, there is still room for
+optimization.  
+
+After the first multiplication inside the quotient ($q_0 \cdot \mu$) the value is shifted right by $m + 1$ places effectively nullifying the lower
+half of the product.  It would be nice to be able to remove those digits from the product to effectively cut down the number of multiplications.  
+If the number of digits in the modulus $m$ is far less than $\beta$ a full product is not required.  In fact the lower $m - 2$ digits will not
+affect the upper half of the product at all and do not need to be computed.  
+
+The value of $\mu$ is a $m$-digit number and $q_0$ is a $m + 1$ digit number.  Using a full multiplier $(m + 1)(m) = m^2 + m$ single precision
+multiplications would be required.  Using a multiplier that will only produce digits at and above the $m - 1$'th digit reduces the number
+of single precision multiplications to ${m^2 + m} \over 2$ single precision multiplications.  
+
+\subsection{Trimming the Residue}
+After the quotient has been calculated it is used to reduce the input.  As previously noted the algorithm is not exact and it can be off by a small
+multiple of the modulus, that is $0 \le a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor < 3b$.  If $b$ is $m$ digits than the 
+result of reduction equation is a value of at most $m + 1$ digits (\textit{provided $3 < \beta$}) implying that the upper $m - 1$ digits are
+implicitly zero.  
+
+The next optimization arises from this very fact.  Instead of computing $b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ using a full
+$O(m^2)$ multiplication algorithm only the lower $m+1$ digits of the product have to be computed.  Similarly the value of $a$ can
+be reduced modulo $\beta^{m+1}$ before the multiple of $b$ is subtracted which simplifes the subtraction as well.  A multiplication that produces 
+only the lower $m+1$ digits requires ${m^2 + 3m - 2} \over 2$ single precision multiplications.  
+
+With both optimizations in place the algorithm is the algorithm Barrett proposed.  It requires $m^2 + 2m - 1$ single precision multiplications which
+is considerably faster than the straightforward $3m^2$ method.  
+
+\subsection{The Barrett Algorithm}
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce}. \\
+\textbf{Input}.   mp\_int $a$, mp\_int $b$ and $\mu = \lfloor \beta^{2m}/b \rfloor$ $(0 \le a < b^2, b > 1)$ \\
+\textbf{Output}.  $c \leftarrow a \mbox{ (mod }b\mbox{)}$ \\
+\hline \\
+Let $m$ represent the number of digits in $b$.  \\
+1.  Make a copy of $a$ and store it in $q$.  (\textit{mp\_init\_copy}) \\
+2.  $q \leftarrow \lfloor q / \beta^{m - 1} \rfloor$ (\textit{mp\_rshd}) \\
+\\
+Produce the quotient. \\
+3.  $q \leftarrow q \cdot \mu$  (\textit{note: only produce digits at or above $m-1$}) \\
+4.  $q \leftarrow \lfloor q / \beta^{m + 1} \rfloor$ \\
+\\
+Subtract the multiple of modulus from the input. \\
+5.  $c \leftarrow a \mbox{ (mod }\beta^{m+1}\mbox{)}$ (\textit{mp\_mod\_2d}) \\
+6.  $q \leftarrow q \cdot b \mbox{ (mod }\beta^{m+1}\mbox{)}$ (\textit{s\_mp\_mul\_digs}) \\
+7.  $c \leftarrow c - q$ (\textit{mp\_sub}) \\
+\\
+Add $\beta^{m+1}$ if a carry occured. \\
+8.  If $c < 0$ then (\textit{mp\_cmp\_d}) \\
+\hspace{3mm}8.1  $q \leftarrow 1$ (\textit{mp\_set}) \\
+\hspace{3mm}8.2  $q \leftarrow q \cdot \beta^{m+1}$ (\textit{mp\_lshd}) \\
+\hspace{3mm}8.3  $c \leftarrow c + q$ \\
+\\
+Now subtract the modulus if the residue is too large (e.g. quotient too small). \\
+9.  While $c \ge b$ do (\textit{mp\_cmp}) \\
+\hspace{3mm}9.1  $c \leftarrow c - b$ \\
+10.  Clear $q$. \\
+11.  Return(\textit{MP\_OKAY}) \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce.}
+This algorithm will reduce the input $a$ modulo $b$ in place using the Barrett algorithm.  It is loosely based on algorithm 14.42 of 
+\cite[pp.  602]{HAC} which is based on \cite{BARRETT}.  The algorithm has several restrictions and assumptions which must be adhered to
+for the algorithm to work.
+
+First the modulus $b$ is assumed to be positive and greater than one.  If the modulus were less than or equal to one than subtracting
+a multiple of it would either accomplish nothing or actually enlarge the input.  The input $a$ must be in the range $0 \le a < b^2$ in order
+for the quotient to have enough precision.  Technically the algorithm will still work if $a \ge b^2$ but it will take much longer to finish.  The
+value of $\mu$ is passed as an argument to this algorithm and is assumed to be setup before the algorithm is used.  
+
+Recall that the multiplication for the quotient on step 3 must only produce digits at or above the $m-1$'th position.  An algorithm called 
+$s\_mp\_mul\_high\_digs$ which has not been presented is used to accomplish this task.  This optimal algorithm can only be used if the number
+of digits in $b$ is very much smaller than $\beta$.  
+
+After the multiple of the modulus has been subtracted from $a$ the residue must be fixed up in case its negative.  While it is known that 
+$a \ge b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ only the lower $m+1$ digits are being used to compute the residue.  In this case 
+the invariant $\beta^{m+1}$ must be added to the residue to make it positive again.  
+
+The while loop at step 9 will subtract $b$ until the residue is less than $b$.  If the algorithm is performed correctly this step is only
+performed upto two times.  However, if $a \ge b^2$ than it will iterate substantially more times than it should.
+
+EXAM,bn_mp_reduce.c
+
+The first multiplication that determines the quotient can be performed by only producing the digits from $m - 1$ and up.  This essentially halves
+the number of single precision multiplications required.  However, the optimization is only safe if $\beta$ is much larger than the number of digits
+in the modulus.  In the source code this is evaluated on lines @36,if@ to @44,}@ where algorithm s\_mp\_mul\_high\_digs is used when it is
+safe to do so.  
+
+\subsection{The Barrett Setup Algorithm}
+In order to use algorithm mp\_reduce the value of $\mu$ must be calculated in advance.  Ideally this value should be computed once and stored for
+future use so that the Barrett algorithm can be used without delay.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce\_setup}. \\
+\textbf{Input}.   mp\_int $a$ ($a > 1$)  \\
+\textbf{Output}.  $\mu \leftarrow \lfloor \beta^{2m}/a \rfloor$ \\
+\hline \\
+1.  $\mu \leftarrow 2^{2 \cdot lg(\beta) \cdot  m}$ (\textit{mp\_2expt}) \\
+2.  $\mu \leftarrow \lfloor \mu / b \rfloor$ (\textit{mp\_div}) \\
+3.  Return(\textit{MP\_OKAY}) \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce\_setup}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce\_setup.}
+This algorithm computes the reciprocal $\mu$ required for Barrett reduction.  First $\beta^{2m}$ is calculated as $2^{2 \cdot lg(\beta) \cdot  m}$ which
+is equivalent and much faster.  The final value is computed by taking the integer quotient of $\lfloor \mu / b \rfloor$.
+
+EXAM,bn_mp_reduce_setup.c
+
+This simple routine calculates the reciprocal $\mu$ required by Barrett reduction.  Note the extended usage of algorithm mp\_div where the variable
+which would received the remainder is passed as NULL.  As will be discussed in ~DIVISION~ the division routine allows both the quotient and the 
+remainder to be passed as NULL meaning to ignore the value.  
+
+\section{The Montgomery Reduction}
+Montgomery reduction\footnote{Thanks to Niels Ferguson for his insightful explanation of the algorithm.} \cite{MONT} is by far the most interesting 
+form of reduction in common use.  It computes a modular residue which is not actually equal to the residue of the input yet instead equal to a 
+residue times a constant.  However, as perplexing as this may sound the algorithm is relatively simple and very efficient.  
+
+Throughout this entire section the variable $n$ will represent the modulus used to form the residue.  As will be discussed shortly the value of
+$n$ must be odd.  The variable $x$ will represent the quantity of which the residue is sought.  Similar to the Barrett algorithm the input
+is restricted to $0 \le x < n^2$.  To begin the description some simple number theory facts must be established.
+
+\textbf{Fact 1.}  Adding $n$ to $x$ does not change the residue since in effect it adds one to the quotient $\lfloor x / n \rfloor$.
+
+\textbf{Fact 2.}  If $x$ is even then performing a division by two in $\Z$ is congruent to $x \cdot 2^{-1} \mbox{ (mod }n\mbox{)}$.  For example,
+if $n = 7$ and $x = 6$ then $x/2 = 3$.  Using the modular inverse of two the same result is found.  That is, $2^{-1} \equiv (n+1)/2 \equiv 4$ and
+$4 \cdot 6 \equiv 3 \mbox{ (mod }n\mbox{)}$.  
+
+From these two simple facts the following simple algorithm can be derived.
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Montgomery Reduction}. \\
+\textbf{Input}.   Integer $x$, $n$ and $k$ \\
+\textbf{Output}.  $2^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  for $t$ from $1$ to $k$ do \\
+\hspace{3mm}1.1  If $x$ is odd then \\
+\hspace{6mm}1.1.1  $x \leftarrow x + n$ \\
+\hspace{3mm}1.2  $x \leftarrow x/2$ \\
+2.  Return $x$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Montgomery Reduction}
+\end{figure}
+
+The algorithm reduces the input one bit at a time using the two congruencies stated previously.  Inside the loop $n$, which is odd, is
+added to $x$ if $x$ is odd.  This forces $x$ to be even which allows the division by two in $\Z$ to be congruent to a modular division by two. 
+
+Let $r$ represent the final result of the Montgomery algorithm.  If $k > lg(n)$ and $0 \le x < n^2$ then the final result is limited to 
+$0 \le r < \lfloor x/2^k \rfloor + n$.  As a result at most a single subtraction is required to get the residue desired.
+
+Let $k = \lfloor lg(n) \rfloor + 1$ represent the number of bits in $n$.  The current algorithm requires $2k^2$ single precision shifts
+and $k^2$ single precision additions.  At this rate the algorithm is most certainly slower than Barrett reduction and not terribly useful.  
+Fortunately there exists an alternative representation of the algorithm.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Montgomery Reduction} (modified I). \\
+\textbf{Input}.   Integer $x$, $n$ and $k$ \\
+\textbf{Output}.  $2^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  for $t$ from $0$ to $k - 1$ do \\
+\hspace{3mm}1.1  If the $t$'th bit of $x$ is one then \\
+\hspace{6mm}1.1.1  $x \leftarrow x + 2^tn$ \\
+2.  Return $x/2^k$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Montgomery Reduction (modified I)}
+\end{figure}
+
+This algorithm is equivalent since $2^tn$ is a multiple of $n$ and the lower $k$ bits of $x$ are zero by step 2.  The number of single
+precision shifts has now been reduced from $2k^2$ to $k^2 + 1$ which is only a small improvement.
+
+\subsection{Digit Based Montgomery Reduction}
+Instead of computing the reduction on a bit-by-bit basis it is actually much faster to compute it on digit-by-digit basis.  Consider the
+previous algorithm re-written to compute the Montgomery reduction in this new fashion.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Montgomery Reduction} (modified II). \\
+\textbf{Input}.   Integer $x$, $n$ and $k$ \\
+\textbf{Output}.  $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  for $t$ from $0$ to $k - 1$ do \\
+\hspace{3mm}1.1  $x \leftarrow x + \mu n \beta^t$ \\
+2.  Return $x/\beta^k$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Montgomery Reduction (modified II)}
+\end{figure}
+
+The value $\mu n \beta^t$ is a multiple of the modulus $n$ meaning that it will not change the residue.  If the first digit of 
+the value $\mu n \beta^t$ equals the negative (modulo $\beta$) of the $t$'th digit of $x$ then the addition will result in a zero digit.  This
+problem breaks down to solving the following congruency.  
+
+\begin{center}
+\begin{tabular}{rcl}
+$x_t + \mu n_0$ & $\equiv$ & $0 \mbox{ (mod }\beta\mbox{)}$ \\
+$\mu n_0$ & $\equiv$ & $-x_t \mbox{ (mod }\beta\mbox{)}$ \\
+$\mu$ & $\equiv$ & $-x_t/n_0 \mbox{ (mod }\beta\mbox{)}$ \\
+\end{tabular}
+\end{center}
+
+In each iteration of the loop on step 1 a new value of $\mu$ must be calculated.  The value of $-1/n_0 \mbox{ (mod }\beta\mbox{)}$ is used 
+extensively in this algorithm and should be precomputed.  Let $\rho$ represent the negative of the modular inverse of $n_0$ modulo $\beta$.  
+
+For example, let $\beta = 10$ represent the radix.  Let $n = 17$ represent the modulus which implies $k = 2$ and $\rho \equiv 7$.  Let $x = 33$ 
+represent the value to reduce.
+
+\newpage\begin{figure}
+\begin{center}
+\begin{tabular}{|c|c|c|}
+\hline \textbf{Step ($t$)} & \textbf{Value of $x$} & \textbf{Value of $\mu$} \\
+\hline --                 & $33$ & --\\
+\hline $0$                 & $33 + \mu n = 50$ & $1$ \\
+\hline $1$                 & $50 + \mu n \beta = 900$ & $5$ \\
+\hline
+\end{tabular}
+\end{center}
+\caption{Example of Montgomery Reduction}
+\end{figure}
+
+The final result $900$ is then divided by $\beta^k$ to produce the final result $9$.  The first observation is that $9 \nequiv x \mbox{ (mod }n\mbox{)}$ 
+which implies the result is not the modular residue of $x$ modulo $n$.  However, recall that the residue is actually multiplied by $\beta^{-k}$ in
+the algorithm.  To get the true residue the value must be multiplied by $\beta^k$.  In this case $\beta^k \equiv 15 \mbox{ (mod }n\mbox{)}$ and
+the correct residue is $9 \cdot 15 \equiv 16 \mbox{ (mod }n\mbox{)}$.  
+
+\subsection{Baseline Montgomery Reduction}
+The baseline Montgomery reduction algorithm will produce the residue for any size input.  It is designed to be a catch-all algororithm for 
+Montgomery reductions.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_montgomery\_reduce}. \\
+\textbf{Input}.   mp\_int $x$, mp\_int $n$ and a digit $\rho \equiv -1/n_0 \mbox{ (mod }n\mbox{)}$. \\
+\hspace{11.5mm}($0 \le x < n^2, n > 1, (n, \beta) = 1, \beta^k > n$) \\
+\textbf{Output}.  $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  $digs \leftarrow 2n.used + 1$ \\
+2.  If $digs < MP\_ARRAY$ and $m.used < \delta$ then \\
+\hspace{3mm}2.1  Use algorithm fast\_mp\_montgomery\_reduce instead. \\
+\\
+Setup $x$ for the reduction. \\
+3.  If $x.alloc < digs$ then grow $x$ to $digs$ digits. \\
+4.  $x.used \leftarrow digs$ \\
+\\
+Eliminate the lower $k$ digits. \\
+5.  For $ix$ from $0$ to $k - 1$ do \\
+\hspace{3mm}5.1  $\mu \leftarrow x_{ix} \cdot \rho \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}5.2  $u \leftarrow 0$ \\
+\hspace{3mm}5.3  For $iy$ from $0$ to $k - 1$ do \\
+\hspace{6mm}5.3.1  $\hat r \leftarrow \mu n_{iy} + x_{ix + iy} + u$ \\
+\hspace{6mm}5.3.2  $x_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{6mm}5.3.3  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+\hspace{3mm}5.4  While $u > 0$ do \\
+\hspace{6mm}5.4.1  $iy \leftarrow iy + 1$ \\
+\hspace{6mm}5.4.2  $x_{ix + iy} \leftarrow x_{ix + iy} + u$ \\
+\hspace{6mm}5.4.3  $u \leftarrow \lfloor x_{ix+iy} / \beta \rfloor$ \\
+\hspace{6mm}5.4.4  $x_{ix + iy} \leftarrow x_{ix+iy} \mbox{ (mod }\beta\mbox{)}$ \\
+\\
+Divide by $\beta^k$ and fix up as required. \\
+6.  $x \leftarrow \lfloor x / \beta^k \rfloor$ \\
+7.  If $x \ge n$ then \\
+\hspace{3mm}7.1  $x \leftarrow x - n$ \\
+8.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_montgomery\_reduce}
+\end{figure}
+
+\textbf{Algorithm mp\_montgomery\_reduce.}
+This algorithm reduces the input $x$ modulo $n$ in place using the Montgomery reduction algorithm.  The algorithm is loosely based
+on algorithm 14.32 of \cite[pp.601]{HAC} except it merges the multiplication of $\mu n \beta^t$ with the addition in the inner loop.  The
+restrictions on this algorithm are fairly easy to adapt to.  First $0 \le x < n^2$ bounds the input to numbers in the same range as 
+for the Barrett algorithm.  Additionally $n > 1$ will ensure a modular inverse $\rho$ exists.  $\rho$ must be calculated in
+advance of this algorithm.  Finally the variable $k$ is fixed and a pseudonym for $n.used$.  
+
+Step 2 decides whether a faster Montgomery algorithm can be used.  It is based on the Comba technique meaning that there are limits on
+the size of the input.  This algorithm is discussed in ~COMBARED~.
+
+Step 5 is the main reduction loop of the algorithm.  The value of $\mu$ is calculated once per iteration in the outer loop.  The inner loop
+calculates $x + \mu n \beta^{ix}$ by multiplying $\mu n$ and adding the result to $x$ shifted by $ix$ digits.  Both the addition and
+multiplication are performed in the same loop to save time and memory.  Step 5.4 will handle any additional carries that escape the inner loop.
+
+Using a quick inspection this algorithm requires $n$ single precision multiplications for the outer loop and $n^2$ single precision multiplications 
+in the inner loop.  In total $n^2 + n$ single precision multiplications which compares favourably to Barrett at $n^2 + 2n - 1$ single precision
+multiplications.  
+
+EXAM,bn_mp_montgomery_reduce.c
+
+This is the baseline implementation of the Montgomery reduction algorithm.  Lines @30,digs@ to @35,}@ determine if the Comba based
+routine can be used instead.  Line @47,mu@ computes the value of $\mu$ for that particular iteration of the outer loop.  
+
+The multiplication $\mu n \beta^{ix}$ is performed in one step in the inner loop.  The alias $tmpx$ refers to the $ix$'th digit of $x$ and
+the alias $tmpn$ refers to the modulus $n$.  
+
+\subsection{Faster ``Comba'' Montgomery Reduction}
+MARK,COMBARED
+
+The Montgomery reduction requires fewer single precision multiplications than a Barrett reduction, however it is much slower due to the serial
+nature of the inner loop.  The Barrett reduction algorithm requires two slightly modified multipliers which can be implemented with the Comba
+technique.  The Montgomery reduction algorithm cannot directly use the Comba technique to any significant advantage since the inner loop calculates
+a $k \times 1$ product $k$ times. 
+
+The biggest obstacle is that at the $ix$'th iteration of the outer loop the value of $x_{ix}$ is required to calculate $\mu$.  This means the 
+carries from $0$ to $ix - 1$ must have been propagated upwards to form a valid $ix$'th digit.  The solution as it turns out is very simple.  
+Perform a Comba like multiplier and inside the outer loop just after the inner loop fix up the $ix + 1$'th digit by forwarding the carry.  
+
+With this change in place the Montgomery reduction algorithm can be performed with a Comba style multiplication loop which substantially increases
+the speed of the algorithm.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{fast\_mp\_montgomery\_reduce}. \\
+\textbf{Input}.   mp\_int $x$, mp\_int $n$ and a digit $\rho \equiv -1/n_0 \mbox{ (mod }n\mbox{)}$. \\
+\hspace{11.5mm}($0 \le x < n^2, n > 1, (n, \beta) = 1, \beta^k > n$) \\
+\textbf{Output}.  $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+Place an array of \textbf{MP\_WARRAY} mp\_word variables called $\hat W$ on the stack. \\
+1.  if $x.alloc < n.used + 1$ then grow $x$ to $n.used + 1$ digits. \\
+Copy the digits of $x$ into the array $\hat W$ \\
+2.  For $ix$ from $0$ to $x.used - 1$ do \\
+\hspace{3mm}2.1  $\hat W_{ix} \leftarrow x_{ix}$ \\
+3.  For $ix$ from $x.used$ to $2n.used - 1$ do \\
+\hspace{3mm}3.1  $\hat W_{ix} \leftarrow 0$ \\
+Elimiate the lower $k$ digits. \\
+4.  for $ix$ from $0$ to $n.used - 1$ do \\
+\hspace{3mm}4.1  $\mu \leftarrow \hat W_{ix} \cdot \rho \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}4.2  For $iy$ from $0$ to $n.used - 1$ do \\
+\hspace{6mm}4.2.1  $\hat W_{iy + ix} \leftarrow \hat W_{iy + ix} + \mu \cdot n_{iy}$ \\
+\hspace{3mm}4.3  $\hat W_{ix + 1} \leftarrow \hat W_{ix + 1} + \lfloor \hat W_{ix} / \beta \rfloor$ \\
+Propagate carries upwards. \\
+5.  for $ix$ from $n.used$ to $2n.used + 1$ do \\
+\hspace{3mm}5.1  $\hat W_{ix + 1} \leftarrow \hat W_{ix + 1} + \lfloor \hat W_{ix} / \beta \rfloor$ \\
+Shift right and reduce modulo $\beta$ simultaneously. \\
+6.  for $ix$ from $0$ to $n.used + 1$ do \\
+\hspace{3mm}6.1  $x_{ix} \leftarrow \hat W_{ix + n.used} \mbox{ (mod }\beta\mbox{)}$ \\
+Zero excess digits and fixup $x$. \\
+7.  if $x.used > n.used + 1$ then do \\
+\hspace{3mm}7.1  for $ix$ from $n.used + 1$ to $x.used - 1$ do \\
+\hspace{6mm}7.1.1  $x_{ix} \leftarrow 0$ \\
+8.  $x.used \leftarrow n.used + 1$ \\
+9.  Clamp excessive digits of $x$. \\
+10.  If $x \ge n$ then \\
+\hspace{3mm}10.1  $x \leftarrow x - n$ \\
+11.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm fast\_mp\_montgomery\_reduce}
+\end{figure}
+
+\textbf{Algorithm fast\_mp\_montgomery\_reduce.}
+This algorithm will compute the Montgomery reduction of $x$ modulo $n$ using the Comba technique.  It is on most computer platforms significantly
+faster than algorithm mp\_montgomery\_reduce and algorithm mp\_reduce (\textit{Barrett reduction}).  The algorithm has the same restrictions
+on the input as the baseline reduction algorithm.  An additional two restrictions are imposed on this algorithm.  The number of digits $k$ in the 
+the modulus $n$ must not violate $MP\_WARRAY > 2k +1$ and $n < \delta$.   When $\beta = 2^{28}$ this algorithm can be used to reduce modulo
+a modulus of at most $3,556$ bits in length.  
+
+As in the other Comba reduction algorithms there is a $\hat W$ array which stores the columns of the product.  It is initially filled with the
+contents of $x$ with the excess digits zeroed.  The reduction loop is very similar the to the baseline loop at heart.  The multiplication on step
+4.1 can be single precision only since $ab \mbox{ (mod }\beta\mbox{)} \equiv (a \mbox{ mod }\beta)(b \mbox{ mod }\beta)$.  Some multipliers such
+as those on the ARM processors take a variable length time to complete depending on the number of bytes of result it must produce.  By performing
+a single precision multiplication instead half the amount of time is spent.
+
+Also note that digit $\hat W_{ix}$ must have the carry from the $ix - 1$'th digit propagated upwards in order for this to work.  That is what step
+4.3 will do.  In effect over the $n.used$ iterations of the outer loop the $n.used$'th lower columns all have the their carries propagated forwards.  Note
+how the upper bits of those same words are not reduced modulo $\beta$.  This is because those values will be discarded shortly and there is no
+point.
+
+Step 5 will propgate the remainder of the carries upwards.  On step 6 the columns are reduced modulo $\beta$ and shifted simultaneously as they are
+stored in the destination $x$.  
+
+EXAM,bn_fast_mp_montgomery_reduce.c
+
+The $\hat W$ array is first filled with digits of $x$ on line @49,for@ then the rest of the digits are zeroed on line @54,for@.  Both loops share
+the same alias variables to make the code easier to read.  
+
+The value of $\mu$ is calculated in an interesting fashion.  First the value $\hat W_{ix}$ is reduced modulo $\beta$ and cast to a mp\_digit.  This
+forces the compiler to use a single precision multiplication and prevents any concerns about loss of precision.   Line @101,>>@ fixes the carry 
+for the next iteration of the loop by propagating the carry from $\hat W_{ix}$ to $\hat W_{ix+1}$.
+
+The for loop on line @113,for@ propagates the rest of the carries upwards through the columns.  The for loop on line @126,for@ reduces the columns
+modulo $\beta$ and shifts them $k$ places at the same time.  The alias $\_ \hat W$ actually refers to the array $\hat W$ starting at the $n.used$'th
+digit, that is $\_ \hat W_{t} = \hat W_{n.used + t}$.  
+
+\subsection{Montgomery Setup}
+To calculate the variable $\rho$ a relatively simple algorithm will be required.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_montgomery\_setup}. \\
+\textbf{Input}.   mp\_int $n$ ($n > 1$ and $(n, 2) = 1$) \\
+\textbf{Output}.  $\rho \equiv -1/n_0 \mbox{ (mod }\beta\mbox{)}$ \\
+\hline \\
+1.  $b \leftarrow n_0$ \\
+2.  If $b$ is even return(\textit{MP\_VAL}) \\
+3.  $x \leftarrow ((b + 2) \mbox{ AND } 4) << 1) + b$ \\
+4.  for $k$ from 0 to $3$ do \\
+\hspace{3mm}4.1  $x \leftarrow x \cdot (2 - bx)$ \\
+5.  $\rho \leftarrow \beta - x \mbox{ (mod }\beta\mbox{)}$ \\
+6.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_montgomery\_setup} 
+\end{figure}
+
+\textbf{Algorithm mp\_montgomery\_setup.}
+This algorithm will calculate the value of $\rho$ required within the Montgomery reduction algorithms.  It uses a very interesting trick 
+to calculate $1/n_0$ when $\beta$ is a power of two.  
+
+EXAM,bn_mp_montgomery_setup.c
+
+This source code computes the value of $\rho$ required to perform Montgomery reduction.  It has been modified to avoid performing excess
+multiplications when $\beta$ is not the default 28-bits.  
+
+\section{The Diminished Radix Algorithm}
+The diminished radix method of modular reduction \cite{DRMET} is a fairly clever technique which is more efficient than either the Barrett
+or Montgomery methods.  The technique is based on a simple congruence.
+
+\begin{equation}
+(x \mbox{ mod } n) + k \lfloor x / n \rfloor \equiv x \mbox{ (mod }(n - k)\mbox{)}
+\end{equation}
+
+This observation was used in the MMB \cite{MMB} block cipher to create a diffusion primitive.  It used the fact that if $n = 2^{31}$ and $k=1$ that 
+then a x86 multiplier could produce the 62-bit product and use  the ``shrd'' instruction to perform a double-precision right shift.  The proof
+of the above equation is very simple.  First write $x$ in the product form.
+
+\begin{equation}
+x = qn + r
+\end{equation}
+
+Now reduce both sides modulo $(n - k)$.
+
+\begin{equation}
+x \equiv qk + r  \mbox{ (mod }(n-k)\mbox{)}
+\end{equation}
+
+The variable $n$ reduces as $n \mbox{ mod } (n - k)$ to $k$.  By putting $q = \lfloor x/n \rfloor$ and $r = x \mbox{ mod } n$ 
+into the equation the original congruence is reproduced.  The following algorithm is based on these observations.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Diminished Radix Reduction}. \\
+\textbf{Input}.   Integer $x$, $n$, $k$ \\
+\textbf{Output}.  $x \mbox{ mod } (n - k)$ \\
+\hline \\
+1.  $q \leftarrow \lfloor x / n \rfloor$ \\
+2.  $q \leftarrow k \cdot q$ \\
+3.  $x \leftarrow x \mbox{ (mod }n\mbox{)}$ \\
+4.  $x \leftarrow x + q$ \\
+5.  If $x \ge (n - k)$ then \\
+\hspace{3mm}5.1  $x \leftarrow x - (n - k)$ \\
+\hspace{3mm}5.2  Goto step 1. \\
+6.  Return $x$ \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Diminished Radix Reduction}
+\label{fig:DR}
+\end{figure}
+
+This algorithm will reduce $x$ modulo $n - k$ and return the residue.  If $0 \le x < (n - k)^2$ then the algorithm will loop almost always
+once or twice and occasionally three times.  For simplicity sake the value of $x$ is bounded by the following simple polynomial.
+
+\begin{equation} 
+0 \le x < n^2 + k^2 - 2nk
+\end{equation}
+
+The true bound is  $0 \le x < (n - k - 1)^2$ but this has quite a few more terms.  The value of $q$ after step 1 is bounded by the following.
+
+\begin{equation}
+q < n - 2k - k^2/n
+\end{equation}
+
+Since $k^2$ is going to be considerably smaller than $n$ that term will always be zero.  The value of $x$ after step 3 is bounded trivially as
+$0 \le x < n$.  By step four the sum $x + q$ is bounded by 
+
+\begin{equation}
+0 \le q + x < (k + 1)n - 2k^2 - 1
+\end{equation}
+
+As a result at most $k$ subtractions of $n$ are required to produce the residue.  With a second pass $q$ will be loosely bounded by $0 \le q < k^2$
+after step 2 while $x$ will still be loosely bounded by $0 \le x < n$ after step 3.  After the second pass it is highly unlike that the
+sum in step 4 will exceed $n - k$.  In practice fewer than three passes of the algorithm are required to reduce virtually every input in the 
+range $0 \le x < (n - k - 1)^2$.  
+
+\subsection{Choice of Moduli}
+On the surface this algorithm looks like a very expensive algorithm.  It requires a couple of subtractions followed by multiplication and other
+modular reductions.  The usefulness of this algorithm becomes exceedingly clear when an appropriate moduli is chosen.
+
+Division in general is a very expensive operation to perform.  The one exception is when the division is by a power of the radix of representation used.  
+Division by ten for example is simple for humans since it amounts to shifting the decimal place.  Similarly division by two 
+(\textit{or powers of two}) is very simple for computers to perform.  It would therefore seem logical to choose $n$ of the form $2^p$ 
+which would imply that $\lfloor x / n \rfloor$ is a simple shift of $x$ right $p$ bits.  
+
+However, there is one operation related to division of power of twos that is even faster than this.  If $n = \beta^p$ then the division may be 
+performed by moving whole digits to the right $p$ places.  In practice division by $\beta^p$ is much faster than division by $2^p$ for any $p$.  
+Also with the choice of $n = \beta^p$ reducing $x$ modulo $n$ requires zeroing the digits above the $p-1$'th digit of $x$.  
+
+Throughout the next section the term ``restricted modulus'' will refer to a modulus of the form $\beta^p - k$ where as the term ``unrestricted
+modulus'' will refer to a modulus of the form $2^p - k$.  The word ``restricted'' in this case refers to the fact that it is based on the 
+$2^p$ logic except $p$ must be a multiple of $lg(\beta)$.  
+
+\subsection{Choice of $k$}
+Now that division and reduction (\textit{step 1 and 3 of figure~\ref{fig:DR}}) have been optimized to simple digit operations the multiplication by $k$
+in step 2 is the most expensive operation.  Fortunately the choice of $k$ is not terribly limited.  For all intents and purposes it might
+as well be a single digit.  
+
+\subsection{Restricted Diminished Radix Reduction}
+The restricted Diminished Radix algorithm can quickly reduce numbers modulo numbers of the form $n = \beta^p - k$.  This algorithm can reduce 
+an input $x$ within the range $0 \le x < n^2$ using a couple passes of the algorithm demonstrated in figure~\ref{fig:DR}.  The implementation
+of this algorithm has been optimized to avoid additional overhead associated with a division by $\beta^p$, the
+multiplication by $k$ or the addition of $x$ and $q$.  The resulting algorithm is very efficient and can lead to substantial improvements when
+modular exponentiations are performed compared to Montgomery based reduction algorithms.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_dr\_reduce}. \\
+\textbf{Input}.   mp\_int $x$, $n$ and a mp\_digit $k = \beta - n_0$ \\
+\hspace{11.5mm}($0 \le x < n^2$, $n > 1$, $0 < k \le \beta$) \\
+\textbf{Output}.  $x \mbox{ mod } n$ \\
+\hline \\
+1.  $m \leftarrow n.used$ \\
+2.  If $x.alloc < 2m$ then grow $x$ to $2m$ digits. \\
+3.  $\mu \leftarrow 0$ \\
+4.  for $i$ from $0$ to $m - 1$ do \\
+\hspace{3mm}4.1  $\hat r \leftarrow k \cdot x_{m+i} + x_{i} + \mu$ \\
+\hspace{3mm}4.2  $x_{i} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}4.3  $\mu \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+5.  $x_{m} \leftarrow \mu$ \\
+6.  for $i$ from $m + 1$ to $x.used - 1$ do \\
+\hspace{3mm}6.1  $x_{i} \leftarrow 0$ \\
+7.  Clamp excess digits of $x$. \\
+8.  If $x \ge n$ then \\
+\hspace{3mm}8.1  $x \leftarrow x - n$ \\
+\hspace{3mm}8.2  Goto step 3. \\
+9.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_dr\_reduce}
+\end{figure}
+
+\textbf{Algorithm mp\_dr\_reduce.}
+This algorithm will perform the dimished radix reduction of $x$ modulo $n$.  It has similar restrictions to that of the Barrett reduction
+with the addition that $n$ must be of the form $n = \beta^m - k$ where $0 < k \le \beta$.  
+
+This algorithm essentially implements the pseudo-code in figure 7.10 except with a slight optimization.  The division by $\beta^m$, multiplication by $k$
+and addition of $x \mbox{ mod }\beta^m$ are all performed as one step inside the loop on step 4.  The division by $\beta^m$ is emulated by accessing
+the term at the $m+i$'th position which is subsequently multiplied by $k$ and added to the term at the $i$'th position.  After the loop the $m$'th
+digit is set to the carry and the upper digits are zeroed.  Step 5 and 6 emulate the reduction modulo $\beta^m$ that should have happend to 
+$x$ before the addition of the multiple of the upper half.  
+
+At step 8 if $x$ is still larger than $n$ another pass of the algorithm is required.  First $n$ is subtracted from $x$ and then the algorithm resumes
+at step 3.  
+
+EXAM,bn_mp_dr_reduce.c
+
+The first step is to grow $x$ as required to $2m$ digits since the reduction is performed in place on $x$.  The label on line @49,top:@ is where
+the algorithm will resume if further reduction passes are required.  In theory it could be placed at the top of the function however, the size of
+the modulus and question of whether $x$ is large enough are invariant after the first pass meaning that it would be a waste of time.  
+
+The aliases $tmpx1$ and $tmpx2$ refer to the digits of $x$ where the latter is offset by $m$ digits.  By reading digits from $x$ offset by $m$ digits
+a division by $\beta^m$ can be simulated virtually for free.  The loop on line @61,for@ performs the bulk of the work (\textit{corresponds to step 4 of algorithm 7.11})
+in this algorithm.
+
+By line @68,mu@ the pointer $tmpx1$ points to the $m$'th digit of $x$ which is where the final carry will be placed.  Similarly by line @71,for@ the 
+same pointer will point to the $m+1$'th digit where the zeroes will be placed.  
+
+Since the algorithm is only valid if both $x$ and $n$ are greater than zero an unsigned comparison suffices to determine if another pass is required.  
+With the same logic at line @82,sub@ the value of $x$ is known to be greater than or equal to $n$ meaning that an unsigned subtraction can be used
+as well.  Since the destination of the subtraction is the larger of the inputs the call to algorithm s\_mp\_sub cannot fail and the return code
+does not need to be checked.
+
+\subsubsection{Setup}
+To setup the restricted Diminished Radix algorithm the value $k = \beta - n_0$ is required.  This algorithm is not really complicated but provided for
+completeness.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_dr\_setup}. \\
+\textbf{Input}.   mp\_int $n$ \\
+\textbf{Output}.  $k = \beta - n_0$ \\
+\hline \\
+1.  $k \leftarrow \beta - n_0$ \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_dr\_setup}
+\end{figure}
+
+EXAM,bn_mp_dr_setup.c
+
+\subsubsection{Modulus Detection}
+Another algorithm which will be useful is the ability to detect a restricted Diminished Radix modulus.  An integer is said to be
+of restricted Diminished Radix form if all of the digits are equal to $\beta - 1$ except the trailing digit which may be any value.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_dr\_is\_modulus}. \\
+\textbf{Input}.   mp\_int $n$ \\
+\textbf{Output}.  $1$ if $n$ is in D.R form, $0$ otherwise \\
+\hline
+1.  If $n.used < 2$ then return($0$). \\
+2.  for $ix$ from $1$ to $n.used - 1$ do \\
+\hspace{3mm}2.1  If $n_{ix} \ne \beta - 1$ return($0$). \\
+3.  Return($1$). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_dr\_is\_modulus}
+\end{figure}
+
+\textbf{Algorithm mp\_dr\_is\_modulus.}
+This algorithm determines if a value is in Diminished Radix form.  Step 1 rejects obvious cases where fewer than two digits are
+in the mp\_int.  Step 2 tests all but the first digit to see if they are equal to $\beta - 1$.  If the algorithm manages to get to
+step 3 then $n$ must of Diminished Radix form.
+
+EXAM,bn_mp_dr_is_modulus.c
+
+\subsection{Unrestricted Diminished Radix Reduction}
+The unrestricted Diminished Radix algorithm allows modular reductions to be performed when the modulus is of the form $2^p - k$.  This algorithm
+is a straightforward adaptation of algorithm~\ref{fig:DR}.
+
+In general the restricted Diminished Radix reduction algorithm is much faster since it has considerably lower overhead.  However, this new
+algorithm is much faster than either Montgomery or Barrett reduction when the moduli are of the appropriate form.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce\_2k}. \\
+\textbf{Input}.   mp\_int $a$ and $n$.  mp\_digit $k$  \\
+\hspace{11.5mm}($a \ge 0$, $n > 1$, $0 < k < \beta$, $n + k$ is a power of two) \\
+\textbf{Output}.  $a \mbox{ (mod }n\mbox{)}$ \\
+\hline
+1.  $p \leftarrow \lfloor lg(n) \rfloor + 1$  (\textit{mp\_count\_bits}) \\
+2.  While $a \ge n$ do \\
+\hspace{3mm}2.1  $q \leftarrow \lfloor a / 2^p \rfloor$ (\textit{mp\_div\_2d}) \\
+\hspace{3mm}2.2  $a \leftarrow a \mbox{ (mod }2^p\mbox{)}$ (\textit{mp\_mod\_2d}) \\
+\hspace{3mm}2.3  $q \leftarrow q \cdot k$ (\textit{mp\_mul\_d}) \\
+\hspace{3mm}2.4  $a \leftarrow a - q$ (\textit{s\_mp\_sub}) \\
+\hspace{3mm}2.5  If $a \ge n$ then do \\
+\hspace{6mm}2.5.1  $a \leftarrow a - n$ \\
+3.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce\_2k}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce\_2k.}
+This algorithm quickly reduces an input $a$ modulo an unrestricted Diminished Radix modulus $n$.
+
+EXAM,bn_mp_reduce_2k.c
+
+\subsubsection{Unrestricted Setup}
+To setup this reduction algorithm the value of $k = 2^p - n$ is required.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce\_2k\_setup}. \\
+\textbf{Input}.   mp\_int $n$   \\
+\textbf{Output}.  $k = 2^p - n$ \\
+\hline
+1.  $p \leftarrow \lfloor lg(n) \rfloor + 1$  (\textit{mp\_count\_bits}) \\
+2.  $x \leftarrow 2^p$ (\textit{mp\_2expt}) \\
+3.  $x \leftarrow x - n$ (\textit{mp\_sub}) \\
+4.  $k \leftarrow x_0$ \\
+5.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce\_2k\_setup}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce\_2k\_setup.}
+
+EXAM,bn_mp_reduce_2k_setup.c
+
+\subsubsection{Unrestricted Detection}
+An integer $n$ is a valid unrestricted Diminished Radix modulus if either of the following are true.
+
+\begin{enumerate}
+\item  The number has only one digit.
+\item  The number has more than one digit and every bit from the $\beta$'th to the most significant is one.
+\end{enumerate}
+
+If either condition is true than there is a power of two namely $2^p$ such that $0 < 2^p - n < \beta$.  
+
+-- Finish this section later, Tom.
+
+\section{Algorithm Comparison}
+So far three very different algorithms for modular reduction have been discussed.  Each of the algorithms have their own strengths and weaknesses
+that makes having such a selection very useful.  The following table sumarizes the three algorithms along with comparisons of work factors.  Since
+all three algorithms have the restriction that $0 \le x < n^2$ and $n > 1$ those limitations are not included in the table.  
+
+\begin{center}
+\begin{small}
+\begin{tabular}{|c|c|c|c|c|c|}
+\hline \textbf{Method} & \textbf{Work Required} & \textbf{Limitations} & \textbf{$m = 8$} & \textbf{$m = 32$} & \textbf{$m = 64$} \\
+\hline Barrett    & $m^2 + 2m - 1$ & None              & $79$ & $1087$ & $4223$ \\
+\hline Montgomery & $m^2 + m$      & $n$ must be odd   & $72$ & $1056$ & $4160$ \\
+\hline D.R.       & $2m$           & $n = \beta^m - k$ & $16$ & $64$   & $128$  \\
+\hline
+\end{tabular}
+\end{small}
+\end{center}
+
+In theory Montgomery and Barrett reductions would require roughly the same amount of time to complete.  However, in practice since Montgomery
+reduction can be written as a single function with the Comba technique it is much faster.  Barrett reduction suffers from the overhead of
+calling the half precision multipliers, addition and division by $\beta$ algorithms.
+
+For almost every cryptographic algorithm Montgomery reduction is the algorithm of choice.  The one set of algorithms where Diminished Radix reduction truly
+shines are based on the discrete logarithm problem such as Diffie-Hellman \cite{DH} and ElGamal \cite{ELGAMAL}.  In these algorithms
+primes of the form $\beta^m - k$ can be found and shared amongst users.  These primes will allow the Diminished Radix algorithm to be used in
+modular exponentiation to greatly speed up the operation.
+
+
+
+\section*{Exercises}
+\begin{tabular}{cl}
+$\left [ 3 \right ]$ & Prove that the ``trick'' in algorithm mp\_montgomery\_setup actually \\
+                     & calculates the correct value of $\rho$. \\
+                     & \\
+$\left [ 2 \right ]$ & Devise an algorithm to reduce modulo $n + k$ for small $k$ quickly.  \\
+                     & \\
+$\left [ 4 \right ]$ & Prove that the pseudo-code algorithm ``Diminished Radix Reduction'' \\
+                     & (\textit{figure 7.10}) terminates.  Also prove the probability that it will \\
+                     & terminate within $1 \le k \le 10$ iterations. \\
+                     & \\
+\end{tabular}                     
+
+
+\chapter{Exponentiation}
+Exponentiation is the operation of raising one variable to the power of another, for example, $a^b$.  A variant of exponentiation, computed
+in a finite field or ring, is called modular exponentiation.  This latter style of operation is typically used in public key 
+cryptosystems such as RSA and Diffie-Hellman.  The ability to quickly compute modular exponentiations is of great benefit to any
+such cryptosystem and many methods have been sought to speed it up.
+
+\section{Exponentiation Basics}
+A trivial algorithm would simply multiply $a$ against itself $b - 1$ times to compute the exponentiation desired.  However, as $b$ grows in size
+the number of multiplications becomes prohibitive.  Imagine what would happen if $b$ $\approx$ $2^{1024}$ as is the case when computing an RSA signature
+with a $1024$-bit key.  Such a calculation could never be completed as it would take simply far too long.
+
+Fortunately there is a very simple algorithm based on the laws of exponents.  Recall that $lg_a(a^b) = b$ and that $lg_a(a^ba^c) = b + c$ which
+are two trivial relationships between the base and the exponent.  Let $b_i$ represent the $i$'th bit of $b$ starting from the least 
+significant bit.  If $b$ is a $k$-bit integer than the following equation is true.
+
+\begin{equation}
+a^b = \prod_{i=0}^{k-1} a^{2^i \cdot b_i}
+\end{equation}
+
+By taking the base $a$ logarithm of both sides of the equation the following equation is the result.
+
+\begin{equation}
+b = \sum_{i=0}^{k-1}2^i \cdot b_i
+\end{equation}
+
+This is indeed true.  The term $a^{2^i}$ can be found from the $i - 1$'th term by squaring the term since $\left ( a^{2^i} \right )^2$ is equal to
+$a^{2^{i+1}}$.  This trivial algorithm forms the basis of essentially all fast exponentiation algorithms.  It requires $k$ squarings and on average
+$k \over 2$ multiplications to compute the result.  This is indeed quite an improvement over simply multiplying by $a$ a total of $b-1$ times.
+
+While this current method is a considerable speed up there are further improvements to be made.  For example, the $a^{2^i}$ term does not need to 
+be an auxilary variable.  Consider the following algorithm.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Left to Right Exponentiation}. \\
+\textbf{Input}.   Integer $a$, $b$ and $k$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $c \leftarrow 1$ \\
+2.  for $i$ from $k - 1$ to $0$ do \\
+\hspace{3mm}2.1  $c \leftarrow c^2$ \\
+\hspace{3mm}2.2  $c \leftarrow c \cdot a^{b_i}$ \\
+3.  Return $c$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Left to Right Exponentiation}
+\end{figure}
+
+This algorithm starts from the most significant bit and works towards the least significant bit.  When the $i$'th bit of $b$ is set $a$ is
+multiplied against the current product.  In each iteration the product is squared which doubles the exponent of the individual terms of the
+product.  
+
+For example, let $b = 101100_2 \equiv 44_{10}$.  The following chart demonstrates the actions of the algorithm.
+
+\newpage\begin{figure}
+\begin{center}
+\begin{tabular}{|c|c|}
+\hline \textbf{Value of $i$} & \textbf{Value of $c$} \\
+\hline - & $1$ \\
+\hline $5$ & $a$ \\
+\hline $4$ & $a^2$ \\
+\hline $3$ & $a^4 \cdot a$ \\
+\hline $2$ & $a^8 \cdot a^2 \cdot a$ \\
+\hline $1$ & $a^{16} \cdot a^4 \cdot a^2$ \\
+\hline $0$ & $a^{32} \cdot a^8 \cdot a^4$ \\
+\hline
+\end{tabular}
+\end{center}
+\caption{Example of Left to Right Exponentiation}
+\end{figure}
+
+When the product $a^{32} \cdot a^8 \cdot a^4$ is simplified it is equal $a^{44}$ which is the desired exponentiation.  This particular algorithm is 
+called ``Left to Right'' because it reads the exponent in that order.  All of the exponentiation algorithms that will be presented are of this nature.  
+
+\subsection{Single Digit Exponentiation}
+The first algorithm in the series of exponentiation algorithms will be an unbounded algorithm where the exponent is a single digit.  It is intended 
+to be used when a small power of an input is required (\textit{e.g. $a^5$}).  It is faster than simply multiplying $b - 1$ times for all values of 
+$b$ that are greater than three.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_expt\_d}. \\
+\textbf{Input}.   mp\_int $a$ and mp\_digit $b$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $g \leftarrow a$ (\textit{mp\_init\_copy}) \\
+2.  $c \leftarrow 1$ (\textit{mp\_set}) \\
+3.  for $x$ from 0 to $lg(\beta) - 1$ do \\
+\hspace{3mm}3.1  $c \leftarrow c^2$ (\textit{mp\_sqr}) \\
+\hspace{3mm}3.2  If $b$ AND $2^{lg(\beta) - 1} \ne 0$ then \\
+\hspace{6mm}3.2.1  $c \leftarrow c \cdot g$ (\textit{mp\_mul}) \\
+\hspace{3mm}3.3  $b \leftarrow b << 1$ \\
+4.  Clear $g$. \\
+5.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_expt\_d}
+\end{figure}
+
+\textbf{Algorithm mp\_expt\_d.}
+This algorithm computes the value of $a$ raised to the power of a single digit $b$.  It uses the left to right exponentiation algorithm to
+quickly compute the exponentiation.  It is loosely based on algorithm 14.79 of HAC \cite[pp. 615]{HAC} with the difference that the 
+exponent is a fixed width.  
+
+A copy of $a$ is made on the first step to allow destination variable $c$ be the same as the source variable $a$.  The result 
+is set to the initial value of $1$ in the subsequent step.
+
+Inside the loop the exponent is read from the most significant bit first downto the least significant bit.  First $c$ is invariably squared
+on step 3.1.  In the following step if the most significant bit of $b$ is one the copy of $a$ is multiplied against the result.  The value
+of $b$ is shifted left one bit to make the next bit down from the most signficant bit become the new most significant bit.  In effect each
+iteration of the loop moves the bits of the exponent $b$ upwards to the most significant location.
+
+EXAM,bn_mp_expt_d.c
+
+-- Some note later.
+
+\subsection{$k$-ary Exponentiation}
+When calculating an exponentiation the most time consuming bottleneck is the multiplications which are in general a small factor
+slower than squaring.  Recall from the previous algorithm that $b_{i}$ refers to the $i$'th bit of the exponent $b$.  Suppose it referred to
+the $i$'th $k$-bit digit of the exponent of $b$.  For $k = 1$ the definitions are synonymous and for $k > 1$ the resulting algorithm
+computes the same exponentiation.  A group of $k$ bits from the exponent is called a \textit{window}.  That is it is a window on a small
+portion of the exponent.  Consider the following modification to the basic left to right exponentiation algorithm.
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{$k$-ary Exponentiation}. \\
+\textbf{Input}.   Integer $a$, $b$, $k$ and $t$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $c \leftarrow 1$ \\
+2.  for $i$ from $t - 1$ to $0$ do \\
+\hspace{3mm}2.1  $c \leftarrow c^{2^k} $ \\
+\hspace{3mm}2.2  Extract the $i$'th $k$-bit word from $b$ and store it in $g$. \\
+\hspace{3mm}2.3  $c \leftarrow c \cdot a^g$ \\
+3.  Return $c$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{$k$-ary Exponentiation}
+\end{figure}
+
+The squaring on step 2.1 can be calculated by squaring the value $c$ successively $k$ times.  If the values of $a^g$ for $0 < g < 2^k$ have been
+precomputed this algorithm requires only $t$ multiplications and $tk$ squarings.  The table can be generated with $2^{k - 1} - 1$ squarings and
+$2^{k - 1} + 1$ multiplications.  This algorithm assumes that the number of bits in the exponent is evenly divisible by $k$.  
+However, when it is not the remaining $0 < x \le k - 1$ bits can be handled with the original left to right style algorithm.
+
+Suppose $k = 4$ and $t = 100$.  This modified algorithm will require $109$ multiplications and $408$ squarings to compute the exponentiation.  The
+original algorithm would on average have required $200$ multiplications and $400$ squrings to compute the same value.  The total number of squarings
+has increased slightly but the number of multiplications has nearly halved.
+
+\subsection{Sliding-Window Exponentiation}
+A simple modification to the previous algorithm is only generate the upper half of the table in the range $2^{k-1} \le g < 2^k$.  Essentially
+this is a table for all values of $g$ where the most significant bit of $g$ is a one.  However, in order for this to be allowed in the 
+algorithm values of $g$ in the range $0 \le g < 2^{k-1}$ must be avoided.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Sliding Window $k$-ary Exponentiation}. \\
+\textbf{Input}.   Integer $a$, $b$, $k$ and $t$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $c \leftarrow 1$ \\
+2.  for $i$ from $t - 1$ to $0$ do \\
+\hspace{3mm}2.1  If the $i$'th bit of $b$ is a zero then \\
+\hspace{6mm}2.1.1   $c \leftarrow c^2$ \\
+\hspace{3mm}2.2  else do \\
+\hspace{6mm}2.2.1  $c \leftarrow c^{2^k}$ \\
+\hspace{6mm}2.2.2  Extract the $k$ bits from $(b_{i}b_{i-1}\ldots b_{i-(k-1)})$ and store it in $g$. \\
+\hspace{6mm}2.2.3  $c \leftarrow c \cdot a^g$ \\
+\hspace{6mm}2.2.4  $i \leftarrow i - k$ \\
+3.  Return $c$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Sliding Window $k$-ary Exponentiation}
+\end{figure}
+
+Similar to the previous algorithm this algorithm must have a special handler when fewer than $k$ bits are left in the exponent.  While this
+algorithm requires the same number of squarings it can potentially have fewer multiplications.  The pre-computed table $a^g$ is also half
+the size as the previous table.  
+
+Consider the exponent $b = 111101011001000_2 \equiv 31432_{10}$ with $k = 3$ using both algorithms.  The first algorithm will divide the exponent up as 
+the following five $3$-bit words $b \equiv \left ( 111, 101, 011, 001, 000 \right )_{2}$.  The second algorithm will break the 
+exponent as $b \equiv \left ( 111, 101, 0, 110, 0, 100, 0 \right )_{2}$.  The single digit $0$ in the second representation are where
+a single squaring took place instead of a squaring and multiplication.  In total the first method requires $10$ multiplications and $18$ 
+squarings.  The second method requires $8$ multiplications and $18$ squarings.  
+
+In general the sliding window method is never slower than the generic $k$-ary method and often it is slightly faster.  
+
+\section{Modular Exponentiation}
+
+Modular exponentiation is essentially computing the power of a base within a finite field or ring.  For example, computing 
+$d \equiv a^b \mbox{ (mod }c\mbox{)}$ is a modular exponentiation.  Instead of first computing $a^b$ and then reducing it 
+modulo $c$ the intermediate result is reduced modulo $c$ after every squaring or multiplication operation.  
+
+This guarantees that any intermediate result is bounded by $0 \le d \le c^2 - 2c + 1$ and can be reduced modulo $c$ quickly using
+any of the three algorithms presented in ~REDUCTION~.  
+
+Before the actual modular exponentiation algorithm can be written a wrapper algorithm must be written first.  This wrapper algorithm
+will allow the exponent $b$ to be negative which is computed as $c \equiv \left (1 / a \right )^{\vert b \vert} \mbox{(mod }d\mbox{)}$. The
+value of $(1/a) \mbox{ mod }c$ is computed using the modular inverse (\textit{see ~MODINV~}).  If no inverse exists the algorithm
+terminates with an error.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_exptmod}. \\
+\textbf{Input}.   mp\_int $a$, $b$ and $c$ \\
+\textbf{Output}.  $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\
+\hline \\
+1.  If $c.sign = MP\_NEG$ return(\textit{MP\_VAL}). \\
+2.  If $b.sign = MP\_NEG$ then \\
+\hspace{3mm}2.1  $g' \leftarrow g^{-1} \mbox{ (mod }c\mbox{)}$ \\
+\hspace{3mm}2.2  $x' \leftarrow \vert x \vert$ \\
+\hspace{3mm}2.3  Compute $d \equiv g'^{x'} \mbox{ (mod }c\mbox{)}$ via recursion. \\
+3.  if ($p$ is odd \textbf{OR} $p$ is a D.R. modulus) \textbf{AND} $p.used  > 4$ then \\
+\hspace{3mm}3.1  Compute $y \equiv g^{x} \mbox{ (mod }p\mbox{)}$ via algorithm mp\_exptmod\_fast. \\
+4.  else \\
+\hspace{3mm}4.1  Compute $y \equiv g^{x} \mbox{ (mod }p\mbox{)}$ via algorithm s\_mp\_exptmod. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_exptmod}
+\end{figure}
+
+\textbf{Algorithm mp\_exptmod.}
+The first algorithm which actually performs modular exponentiation is algorithm s\_mp\_exptmod.  It is a sliding window $k$-ary algorithm 
+which uses Barrett reduction to reduce the product modulo $p$.  The second algorithm mp\_exptmod\_fast performs the same operation 
+except it uses either Montgomery or Diminished Radix reduction.  The two latter reduction algorithms are clumped in the same exponentiation
+algorithm since their arguments are essentially the same (\textit{two mp\_ints and one mp\_digit}).  
+
+EXAM,bn_mp_exptmod.c
+
+\subsection{Barrett Modular Exponentiation}
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{s\_mp\_exptmod}. \\
+\textbf{Input}.   mp\_int $a$, $b$ and $c$ \\
+\textbf{Output}.  $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\
+\hline \\
+1.  $k \leftarrow lg(x)$ \\
+2.  $winsize \leftarrow  \left \lbrace \begin{array}{ll}
+                              2 &  \mbox{if }k \le 7 \\
+                              3 &  \mbox{if }7 < k \le 36 \\
+                              4 &  \mbox{if }36 < k \le 140 \\
+                              5 &  \mbox{if }140 < k \le 450 \\
+                              6 &  \mbox{if }450 < k \le 1303 \\
+                              7 &  \mbox{if }1303 < k \le 3529 \\
+                              8 &  \mbox{if }3529 < k \\
+                              \end{array} \right .$ \\
+3.  Initialize $2^{winsize}$ mp\_ints in an array named $M$ and one mp\_int named $\mu$ \\
+4.  Calculate the $\mu$ required for Barrett Reduction (\textit{mp\_reduce\_setup}). \\
+5.  $M_1 \leftarrow g \mbox{ (mod }p\mbox{)}$ \\
+\\
+Setup the table of small powers of $g$.  First find $g^{2^{winsize}}$ and then all multiples of it. \\
+6.  $k \leftarrow 2^{winsize - 1}$ \\
+7.  $M_{k} \leftarrow M_1$ \\
+8.  for $ix$ from 0 to $winsize - 2$ do \\
+\hspace{3mm}8.1  $M_k \leftarrow \left ( M_k \right )^2$ \\
+\hspace{3mm}8.2  $M_k \leftarrow M_k \mbox{ (mod }p\mbox{)}$ (\textit{mp\_reduce}) \\
+9.  for $ix$ from $2^{winsize - 1} + 1$ to $2^{winsize} - 1$ do \\
+\hspace{3mm}9.1  $M_{ix} \leftarrow M_{ix - 1} \cdot M_{1}$ \\
+\hspace{3mm}9.2  $M_{ix} \leftarrow M_{ix} \mbox{ (mod }p\mbox{)}$ (\textit{mp\_reduce}) \\
+10.  $res \leftarrow 1$ \\
+\\
+Start Sliding Window. \\
+11.  $mode \leftarrow 0, bitcnt \leftarrow 1, buf \leftarrow 0, digidx \leftarrow x.used - 1, bitcpy \leftarrow 0, bitbuf \leftarrow 0$ \\
+12.  Loop \\
+\hspace{3mm}12.1  $bitcnt \leftarrow bitcnt - 1$ \\
+\hspace{3mm}12.2  If $bitcnt = 0$ then do \\
+\hspace{6mm}12.2.1  If $digidx = -1$ goto step 13. \\
+\hspace{6mm}12.2.2  $buf \leftarrow x_{digidx}$ \\
+\hspace{6mm}12.2.3  $digidx \leftarrow digidx - 1$ \\
+\hspace{6mm}12.2.4  $bitcnt \leftarrow lg(\beta)$ \\
+Continued on next page. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm s\_mp\_exptmod}
+\end{figure}
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{s\_mp\_exptmod} (\textit{continued}). \\
+\textbf{Input}.   mp\_int $a$, $b$ and $c$ \\
+\textbf{Output}.  $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\
+\hline \\
+\hspace{3mm}12.3  $y \leftarrow (buf >> (lg(\beta) - 1))$ AND $1$ \\
+\hspace{3mm}12.4  $buf \leftarrow buf << 1$ \\
+\hspace{3mm}12.5  if $mode = 0$ and $y = 0$ then goto step 12. \\
+\hspace{3mm}12.6  if $mode = 1$ and $y = 0$ then do \\
+\hspace{6mm}12.6.1  $res \leftarrow res^2$ \\
+\hspace{6mm}12.6.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}12.6.3  Goto step 12. \\
+\hspace{3mm}12.7  $bitcpy \leftarrow bitcpy + 1$ \\
+\hspace{3mm}12.8  $bitbuf \leftarrow bitbuf + (y << (winsize - bitcpy))$ \\
+\hspace{3mm}12.9  $mode \leftarrow 2$ \\
+\hspace{3mm}12.10  If $bitcpy = winsize$ then do \\
+\hspace{6mm}Window is full so perform the squarings and single multiplication. \\
+\hspace{6mm}12.10.1  for $ix$ from $0$ to $winsize -1$ do \\
+\hspace{9mm}12.10.1.1  $res \leftarrow res^2$ \\
+\hspace{9mm}12.10.1.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}12.10.2  $res \leftarrow res \cdot M_{bitbuf}$ \\
+\hspace{6mm}12.10.3  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}Reset the window. \\
+\hspace{6mm}12.10.4  $bitcpy \leftarrow 0, bitbuf \leftarrow 0, mode \leftarrow 1$ \\
+\\
+No more windows left.  Check for residual bits of exponent. \\
+13.  If $mode = 2$ and $bitcpy > 0$ then do \\
+\hspace{3mm}13.1  for $ix$ form $0$ to $bitcpy - 1$ do \\
+\hspace{6mm}13.1.1  $res \leftarrow res^2$ \\
+\hspace{6mm}13.1.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}13.1.3  $bitbuf \leftarrow bitbuf << 1$ \\
+\hspace{6mm}13.1.4  If $bitbuf$ AND $2^{winsize} \ne 0$ then do \\
+\hspace{9mm}13.1.4.1  $res \leftarrow res \cdot M_{1}$ \\
+\hspace{9mm}13.1.4.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+14.  $y \leftarrow res$ \\
+15.  Clear $res$, $mu$ and the $M$ array. \\
+16.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm s\_mp\_exptmod (continued)}
+\end{figure}
+
+\textbf{Algorithm s\_mp\_exptmod.}
+This algorithm computes the $x$'th power of $g$ modulo $p$ and stores the result in $y$.  It takes advantage of the Barrett reduction
+algorithm to keep the product small throughout the algorithm.
+
+The first two steps determine the optimal window size based on the number of bits in the exponent.  The larger the exponent the 
+larger the window size becomes.  After a window size $winsize$ has been chosen an array of $2^{winsize}$ mp\_int variables is allocated.  This
+table will hold the values of $g^x \mbox{ (mod }p\mbox{)}$ for $2^{winsize - 1} \le x < 2^{winsize}$.  
+
+After the table is allocated the first power of $g$ is found.  Since $g \ge p$ is allowed it must be first reduced modulo $p$ to make
+the rest of the algorithm more efficient.  The first element of the table at $2^{winsize - 1}$ is found by squaring $M_1$ successively $winsize - 2$
+times.  The rest of the table elements are found by multiplying the previous element by $M_1$ modulo $p$.
+
+Now that the table is available the sliding window may begin.  The following list describes the functions of all the variables in the window.
+\begin{enumerate}
+\item The variable $mode$ dictates how the bits of the exponent are interpreted.  
+\begin{enumerate}
+   \item When $mode = 0$ the bits are ignored since no non-zero bit of the exponent has been seen yet.  For example, if the exponent were simply 
+         $1$ then there would be $lg(\beta) - 1$ zero bits before the first non-zero bit.  In this case bits are ignored until a non-zero bit is found.  
+   \item When $mode = 1$ a non-zero bit has been seen before and a new $winsize$-bit window has not been formed yet.  In this mode leading $0$ bits 
+         are read and a single squaring is performed.  If a non-zero bit is read a new window is created.  
+   \item When $mode = 2$ the algorithm is in the middle of forming a window and new bits are appended to the window from the most significant bit
+         downards.
+\end{enumerate}
+\item The variable $bitcnt$ indicates how many bits are left in the current digit of the exponent left to be read.  When it reaches zero a new digit
+      is fetched from the exponent.
+\item The variable $buf$ holds the currently read digit of the exponent. 
+\item The variable $digidx$ is an index into the exponents digits.  It starts at the leading digit $x.used - 1$ and moves towards the trailing digit.
+\item The variable $bitcpy$ indicates how many bits are in the currently formed window.  When it reaches $winsize$ the window is flushed and
+      the appropriate operations performed.
+\item The variable $bitbuf$ holds the current bits of the window being formed.  
+\end{enumerate}
+
+All of step 12 is the window processing loop.  It will iterate while there are digits available form the exponent to read.  The first step
+inside this loop is to extract a new digit if no more bits are available in the current digit.  If there are no bits left a new digit is
+read and if there are no digits left than the loop terminates.  
+
+After a digit is made available step 12.3 will extract the most significant bit of the current digit and move all other bits in the digit
+upwards.  In effect the digit is read from most significant bit to least significant bit and since the digits are read from leading to 
+trailing edges the entire exponent is read from most significant bit to least significant bit.
+
+At step 12.5 if the $mode$ and currently extracted bit $y$ are both zero the bit is ignored and the next bit is read.  This prevents the 
+algorithm from having todo trivial squaring and reduction operations before the first non-zero bit is read.  Step 12.6 and 12.7-10 handle
+the two cases of $mode = 1$ and $mode = 2$ respectively.  
+
+FIGU,expt_state,Sliding Window State Diagram
+
+By step 13 there are no more digits left in the exponent.  However, there may be partial bits in the window left.  If $mode = 2$ then 
+a Left-to-Right algorithm is used to process the remaining few bits.  
+
+EXAM,bn_s_mp_exptmod.c
+
+\section{Quick Power of Two}
+Calculating $b = 2^a$ can be performed much quicker than with any of the previous algorithms.  Recall that a logical shift left $m << k$ is
+equivalent to $m \cdot 2^k$.  By this logic when $m = 1$ a quick power of two can be achieved.
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_2expt}. \\
+\textbf{Input}.   integer $b$ \\
+\textbf{Output}.  $a \leftarrow 2^b$ \\
+\hline \\
+1.  $a \leftarrow 0$ \\
+2.  If $a.alloc < \lfloor b / lg(\beta) \rfloor + 1$ then grow $a$ appropriately. \\
+3.  $a.used \leftarrow \lfloor b / lg(\beta) \rfloor + 1$ \\
+4.  $a_{\lfloor b / lg(\beta) \rfloor} \leftarrow 1 << (b \mbox{ mod } lg(\beta))$ \\
+5.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_2expt}
+\end{figure}
+
+\textbf{Algorithm mp\_2expt.}
+
+EXAM,bn_mp_2expt.c
+
+
+\chapter{Higher Level Algorithms}
+\section{Integer Division with Remainder}
+MARK,DIVISION
+
+\section{Single Digit Helpers}
+\subsection{Single Digit Addition}
+\subsection{Single Digit Subtraction}
+\subsection{Single Digit Multiplication}
+\subsection{Single Digit Division}
+\subsection{Single Digit Modulo}
+\subsection{Single Digit Root Extraction}
+\section{Random Number Generation}
+\section{Formatted Output}
+\subsection{Getting The Output Size}
+\subsection{Generating Radix-n Output}
+\subsection{Reading Radix-n Input}
+\section{Unformatted Output}
+\subsection{Getting The Output Size}
+\subsection{Generating Output}
+\subsection{Reading Input}
+
+\chapter{Number Theoretic Algorithms}
+\section{Greatest Common Divisor}
+\section{Least Common Multiple}
+\section{Jacobi Symbol Computation}
+\section{Modular Inverse}
+MARK,MODINV
+\subsection{General Case}
+\subsection{Odd Moduli}
+\section{Primality Tests}
+\subsection{Trial Division}
+\subsection{The Fermat Test}
+\subsection{The Miller-Rabin Test}
+\subsection{Primality Test in a Bottle}
+\subsection{The Next Prime}
+\section{Root Extraction}
+
+\backmatter
+\appendix
+\begin{thebibliography}{ABCDEF}
+\bibitem[1]{TAOCPV2}
+Donald Knuth, \textit{The Art of Computer Programming}, Third Edition, Volume Two, Seminumerical Algorithms, Addison-Wesley, 1998
+
+\bibitem[2]{HAC}
+A. Menezes, P. van Oorschot, S. Vanstone, \textit{Handbook of Applied Cryptography}, CRC Press, 1996
+
+\bibitem[3]{ROSE}
+Michael Rosing, \textit{Implementing Elliptic Curve Cryptography}, Manning Publications, 1999
+
+\bibitem[4]{COMBA}
+Paul G. Comba, \textit{Exponentiation Cryptosystems on the IBM PC}. IBM Systems Journal 29(4): 526-538 (1990)
+
+\bibitem[5]{KARA}
+A. Karatsuba, Doklay Akad. Nauk SSSR 145 (1962), pp.293-294
+
+\bibitem[6]{KARAP}
+Andre Weimerskirch and Christof Paar, \textit{Generalizations of the Karatsuba Algorithm for Polynomial Multiplication}, Submitted to Design, Codes and Cryptography, March 2002
+
+\bibitem[7]{BARRETT}
+Paul Barrett, \textit{Implementing the Rivest Shamir and Adleman Public Key Encryption Algorithm on a Standard Digital Signal Processor}, Advances in Cryptology, Crypto '86, Springer-Verlag.
+
+\bibitem[8]{MONT}
+P.L.Montgomery. \textit{Modular multiplication without trial division}. Mathematics of Computation, 44(170):519-521, April 1985.
+
+\bibitem[9]{DRMET}
+Chae Hoon Lim and Pil Joong Lee, \textit{Generating Efficient Primes for Discrete Log Cryptosystems}, POSTECH Information Research Laboratories
+
+\bibitem[10]{MMB}
+J. Daemen and R. Govaerts and J. Vandewalle, \textit{Block ciphers based on Modular Arithmetic}, State and {P}rogress in the {R}esearch of {C}ryptography, 1993, pp. 80-89
 
 \end{thebibliography}
 
diff --git a/tommath.tex b/tommath.tex
index ae4cb61..289af59 100644
--- a/tommath.tex
+++ b/tommath.tex
@@ -59,16 +59,16 @@ Algonquin College \\
 Mads Rasmussen \\
 Open Communications Security \\
 \\
-Gregory Rose \\
-Qualcomm \\
+Greg Rose \\
+QUALCOMM Australia \\
 \end{tabular}
 %\end{small}
 }
 }
 \maketitle
-This text in its entirety is copyrighted \copyright{}2003 by Tom St Denis.  It may not be redistributed 
-electronically or otherwise without the sole permission of the author.  The text is freely re distributable as long as
-it is packaged along with the LibTomMath project in a non-commercial project.  Contact the
+This text in its entirety is copyright \copyright{}2003 by Tom St Denis.  It may not be redistributed 
+electronically or otherwise without the sole permission of the author.  The text is freely redistributable as long as
+it is packaged along with the LibTomMath library in a non-commercial project.  Contact the
 author for other redistribution rights.
 
 This text corresponds to the v0.17 release of the LibTomMath project.
@@ -105,13 +105,13 @@ single-precision data types which are incapable of precisely representing intege
 For example, consider multiplying $1,234,567$ by $9,876,543$ in C with an ``unsigned long'' data type.  With an 
 x86 machine the result is $4,136,875,833$ while the true result is $12,193,254,061,881$.  The original inputs 
 were approximately $21$ and $24$ bits respectively.  If the C language cannot multiply two relatively small values 
-together precisely how does anyone expect it to multiply two values which are considerably larger?
+together precisely how does anyone expect it to multiply two values that are considerably larger?
 
-Most advancements in fast multiple precision arithmetic stems from the desire for faster cryptographic primitives.  However, cryptography
-is not the only field of study that can benefit fast large integer routines.  Another auxiliary use for multiple precision integers is 
+Most advancements in fast multiple precision arithmetic stem from the desire for faster cryptographic primitives.  However, cryptography
+is not the only field of study that can benefit from fast large integer routines.  Another auxiliary use for multiple precision integers is 
 high precision floating point data types.  The basic IEEE standard floating point type is made up of an integer mantissa $q$ and an exponent $e$.  
-Numbers are given in the form $n = q \cdot b^e$ where $b = 2$ is convention.  Since IEEE is meant to be implemented in 
-hardware the precision of the mantissa is often fairly small (\textit{roughly 23 bits}).  Since the mantissa is merely an 
+Numbers are given in the form $n = q \cdot b^e$ where $b = 2$ is specified.  Since IEEE is meant to be implemented in 
+hardware the precision of the mantissa is often fairly small (\textit{23, 48 and 64 bits}).  Since the mantissa is merely an 
 integer a large multiple precision integer could be used.  In effect very high precision floating point arithmetic 
 could be performed.  This would be useful where scientific applications must minimize the total output error over long simulations.  
 
@@ -122,15 +122,15 @@ the C and Java programming languages.  In essence multiple precision arithmetic 
 performed on members of an algebraic group whose precision is not fixed.  The algorithms when implemented to be multiple
 precision can allow a developer to work with any practical precision required.
 
-Typically the arithmetic is performed over the ring of integers denoted by a $\Z$ and referred to casually as ``bignum'' 
-routines.  However, it is possible to have rings of polynomials as well typically denoted by $\Z/p\Z \left [ X \right ]$ 
-which could have variable precision (\textit{or degree}).  This text will discuss implementation of the former, however,
-implementing polynomial basis routines should be relatively easy after reading this text.
+Typically the arithmetic over the ring of integers denoted by $\Z$ is performed by routines that are collectively and 
+casually referred to as ``bignum'' routines.  However, it is possible to have rings of polynomials as well typically 
+denoted by $\Z/p\Z \left [ X \right ]$ which could have variable precision (\textit{or degree}).  This text will 
+discuss implementation of the former, however implementing polynomial basis routines should be relatively easy after reading this text.
 
 \subsection{Benefits of Multiple Precision Arithmetic}
 \index{precision} \index{accuracy}
-Precision is defined loosely as the proximity to the real value a given representation is.  Accuracy is defined as the 
-reproducibility of the result.  For example, the calculation $1/3 = 0.25$ is imprecise but can be accurate provided 
+Precision of the real value to a given precision is defined loosely as the proximity of the real value to a given representation.  
+Accuracy is defined as the reproducibility of the result.  For example, the calculation $1/3 = 0.25$ is imprecise but can be accurate provided 
 it is reproducible.
 
 The benefit of multiple precision representations over single precision representations is that 
@@ -144,12 +144,12 @@ modest computer resources.  The only reasonable case where a multiple precision 
 emulating a floating point data type.  However, with multiple precision integer arithmetic no precision is lost.
 
 \subsection{Basis of Operations}
-At the heart of all multiple precision integer operations are the ``long-hand'' algorithms we all learnt as children 
+At the heart of all multiple precision integer operations are the ``long-hand'' algorithms we all learned as children 
 in grade school.  For example, to multiply $1,234$ by $981$ the student is not taught to memorize the times table for 
-$1,234$ instead they are taught how to long-multiply.  That is to multiply each column using simple single digit 
-multiplications and add the resulting products by column.  The representation that most are familiar with is known as 
-decimal or formally as radix-10. A radix-$n$ representation simply means there are $n$ possible values per digit.  
-For example, binary would be a radix-2 representation.
+$1,234$, instead they are taught how to long-multiply.  That is to multiply each column using simple single digit 
+multiplications, line up the partial results, and add the resulting products by column.  The representation that most 
+are familiar with is known as decimal or formally as radix-10. A radix-$n$ representation simply means there are 
+$n$ possible values per digit.  For example, binary would be a radix-2 representation.
 
 In essence computer based multiple precision arithmetic is very much the same.  The most notable difference is the usage
 of a binary friendly radix.  That is to use a radix of the form $2^k$ where $k$ is typically the size of a machine 
@@ -159,22 +159,21 @@ squaring instead of traditional long-hand algorithms.
 \section{Purpose of This Text}
 The purpose of this text is to instruct the reader regarding how to implement multiple precision algorithms.  That is 
 to not only explain the core theoretical algorithms but also the various ``house keeping'' tasks that are neglected by
-authors of other texts on the subject.  Texts such as Knuths' ``The Art of Computer Programming, vol 2.'' and the 
-Handbook of Applied Cryptography (\textit{HAC}) give considerably detailed explanations of the theoretical aspects of 
-the algorithms and very little regarding the practical aspects.  
+authors of other texts on the subject.  Texts such as \cite[HAC]{HAC} and \cite{TAOCPV2} give considerably detailed 
+explanations of the theoretical aspects of the algorithms and very little regarding the practical aspects.  
 
-That is how an algorithm is explained and how it is actually implemented are two very different 
+How an algorithm is explained and how it is actually implemented are two very different 
 realities.  For example, algorithm 14.7 on page 594 of HAC lists a relatively simple algorithm for performing multiple 
 precision integer addition.  However, what the description lacks is any discussion concerning the fact that the two 
 integer inputs may be of differing magnitudes.  Similarly the division routine (\textit{Algorithm 14.20, pp. 598}) 
-does not discuss how to handle sign or handle the dividends decreasing magnitude in the main loop (\textit{Step \#3}).
+does not discuss how to handle sign or handle the dividend's decreasing magnitude in the main loop (\textit{Step \#3}).
 
 As well as the numerous practical oversights both of the texts do not discuss several key optimal algorithms required 
-such as ``Comba'' and Karatsuba multipliers and fast modular inversion.  These optimal algorithms are considerably
-vital to achieve any form of useful performance in non-trivial applications.  
+such as ``Comba'' and Karatsuba multipliers and fast modular inversion.  These optimal algorithms are vital to achieve 
+any form of useful performance in non-trivial applications.  
 
 To solve this problem the focus of this text is on the practical aspects of implementing the algorithms that 
-constitute a multiple precision integer package with light cursory discussions on the theoretical aspects.  As a case 
+constitute a multiple precision integer package with light discussions on the theoretical aspects.  As a case 
 study the ``LibTomMath''\footnote{Available freely at http://math.libtomcrypt.org} package is used to demonstrate 
 algorithms with implementations that have been field tested and work very well.
 
@@ -182,8 +181,8 @@ algorithms with implementations that have been field tested and work very well.
 \subsection{Notation}
 A multiple precision integer of $n$-digits shall be denoted as $x = (x_n ... x_1 x_0)_{ \beta }$ to be the 
 multiple precision notation for the integer $x \equiv \sum_{i=0}^{n} x_i\beta^i$.  The elements of the array $x$ are
-said to be the radix $\beta$ digits of the integer.  For example, $x = (15,0,7)_{\beta}$ would represent the 
-integer $15\cdot\beta^2 + 0\cdot\beta^1 + 7\cdot\beta^0$.  
+said to be the radix $\beta$ digits of the integer.  For example, $x = (1,2,3)_{10}$ would represent the 
+integer $1\cdot 10^2 + 2\cdot10^1 + 3\cdot10^0 = 123$.  
 
 A ``mp\_int'' shall refer to a composite structure which contains the digits of the integer as well as auxilary data
 required to manipulate the data.  These additional members are discussed in chapter three.  For the purposes of this text
@@ -198,6 +197,11 @@ will be stored in a double-precision arrays.  For the purposes of this text $x_j
 $j$'th digit of a single-precision array and $\hat x_j$ will refer to the $j$'th digit of a double-precision
 array.
 
+The $\lfloor \mbox{ } \rfloor$ brackets represent a value truncated and rounded down to the nearest integer.  The $\lceil \mbox{ } \rceil$ brackets 
+represent a value truncated and rounded up to the nearest integer.  Typically when the $/$ division symbol is used the intention is to perform an integer
+division.  For example, $5/2 = 2$ which will often be written as $\lfloor 5/2 \rfloor = 2$ for clarity.  When a value is presented as a fraction
+such as $5 \over 2$ a real value division is implied.
+
 \subsection{Work Effort}
 \index{big-O}
 To measure the efficiency of various algorithms a modified big-O notation is used.  In this system all 
@@ -218,7 +222,7 @@ off the most at the higher levels since they represent the bulk of the effort re
 
 \section{Exercises}
 Within the more advanced chapters a section will be set aside to give the reader some challenging exercises.  These exercises are not 
-designed to be prize winning problems yet instead to be thought provoking.  Wherever possible the problems are foreward minded stating 
+designed to be prize winning problems, but to be thought provoking.  Wherever possible the problems are forward minded stating 
 problems that will be answered in subsequent chapters.  The reader is encouraged to finish the exercises as they appear to get a 
 better understanding of the subject material.  
 
@@ -267,39 +271,38 @@ is encouraged to answer the follow-up problems and try to draw the relevence of 
 
 \chapter{Introduction to LibTomMath}
 
-\section{What is the LibTomMath?}
-LibTomMath is a free and open source multiple precision number theoretic library written in portable ISO C
-source code.  By portable it is meant that the library does not contain any code that is platform dependent or otherwise
-problematic to use on any given platform.  The library has been successfully tested under numerous operating systems 
-including Solaris, MacOS, Windows, Linux, PalmOS and on standalone hardware such as the Gameboy Advance.  The 
-library is designed to contain enough functionality to be able to develop number theoretic applications such as public 
-key cryptosystems.
+\section{What is LibTomMath?}
+LibTomMath is a free and open source multiple precision library written in portable ISO C source code.  By portable it is 
+meant that the library does not contain any code that is computer platform dependent or otherwise problematic to use on any 
+given platform.  The library has been successfully tested under numerous operating systems including Solaris, MacOS, Windows, 
+Linux, PalmOS and on standalone hardware such as the Gameboy Advance.  The library is designed to contain enough 
+functionality to be able to develop applications such as public key cryptosystems.
 
-\section{Goals of the LibTomMath}
+\section{Goals of LibTomMath}
 
 Even though the library is written entirely in portable ISO C considerable care has been taken to 
 optimize the algorithm implementations within the library.  Specifically the code has been written to work well with
-the GNU C Compiler (\textit{GCC}) on both x86 and ARMv4 processors.  Wherever possible optimal 
-algorithms (\textit{such as Karatsuba multiplication, sliding window exponentiation and Montgomery reduction.}) have 
+the GNU C Compiler (\textit{GCC}) on both x86 and ARMv4 processors.  Wherever possible highly efficient 
+algorithms (\textit{such as Karatsuba multiplication, sliding window exponentiation and Montgomery reduction}) have 
 been provided to make the library as efficient as possible.  Even with the optimal and sometimes specialized 
-algorithms that have been included the API has been kept as simple as possible.  Often generic place holder routines 
-will make use of specialized algorithms automatically without the developers attention.  One such example
-is the generic multiplication algorithm \textbf{mp\_mul()} which will automatically use Karatsuba multiplication if the 
-inputs are of a specific size.
+algorithms that have been included the Application Programing Interface (\textit{API}) has been kept as simple as possible.  
+Often generic place holder routines will make use of specialized algorithms automatically without the developer's
+attention.  One such example is the generic multiplication algorithm \textbf{mp\_mul()} which will automatically use 
+Karatsuba multiplication if the inputs are of a specific size.
 
 Making LibTomMath as efficient as possible is not the only goal of the LibTomMath project.  Ideally the library should 
 be source compatible with another popular library which makes it more attractive for developers to use.  In this case the
 MPI library was used as a API template for all the basic functions.
 
-The project is also meant to act as a learning tool for students.  The logic being that no easy to follow ``bignum'' 
+The project is also meant to act as a learning tool for students.  The logic being that no easy-to-follow ``bignum'' 
 library exists which can be used to teach computer science students how to perform fast and reliable multiple precision 
-arithmetic.  To this end the source code has been given quite a few comments and algorithm discussion points.  Often 
-where applicable routines have more comments than lines of code.
+arithmetic.  To this end the source code has been given quite a few comments and algorithm discussion points.  Often routines have 
+more comments than lines of code.
 
 \section{Choice of LibTomMath}
 LibTomMath was chosen as the case study of this text not only because the author of both projects is one and the same but
 for more worthy reasons.  Other libraries such as GMP, MPI, LIP and OpenSSL have multiple precision 
-integer arithmetic routines but would not be ideal for this text for numerous reasons as will be explained in the 
+integer arithmetic routines but would not be ideal for this text for reasons as will be explained in the 
 following sub-sections.
 
 \subsection{Code Base}
@@ -308,17 +311,16 @@ segments of code littered throughout the source.  This clean and uncluttered app
 developer can more readily ascertain the true intent of a given section of source code without trying to keep track of
 what conditional code will be used.
 
-The code base of LibTomMath is also exceptionally well organized.  Each function is in its own separate source code file 
+The code base of LibTomMath is also well organized.  Each function is in its own separate source code file 
 which allows the reader to find a given function very fast.  When compiled with GCC for the x86 processor the entire 
 library is a mere 87,760 bytes (\textit{$116,182$ bytes for ARMv4 processors}).  This includes every single function 
 LibTomMath provides from basic arithmetic to various number theoretic functions such as modular exponentiation, various 
 reduction algorithms and Jacobi symbol computation.  
 
-By comparison MPI which has fewer number theoretic functions than LibTomMath compiled with the same conditions is 
-45,429 bytes (\textit{$54,536$ for ARMv4}).  GMP which has rather large collection of functions with the default 
-configuration on an x86 Athlon is 2,950,688 bytes.  Note that while LibTomMath has fewer functions than GMP it has been
-been used as the sole basis for several public key cryptosystems without having to seek additional outside functions
-to supplement the library.
+By comparison MPI which has fewer functions than LibTomMath compiled with the same conditions is 45,429 bytes 
+(\textit{$54,536$ for ARMv4}).  GMP which has rather large collection of functions with the default configuration on an 
+x86 Athlon is 2,950,688 bytes.  Note that while LibTomMath has fewer functions than GMP it has been used as the sole basis 
+for several public key cryptosystems without having to seek additional outside functions to supplement the library.
 
 \subsection{API Simplicity}
 LibTomMath is designed after the MPI library and shares the API design.  Quite often programs that use MPI will build 
@@ -335,7 +337,7 @@ While LibTomMath is certainly not the fastest library (\textit{GMP often beats L
 feature a set of optimal algorithms for tasks ranging from modular reduction to squaring.  GMP and LIP also feature
 such optimizations while MPI only uses baseline algorithms with no optimizations.
 
-LibTomMath is almost always a magnitude faster than the MPI library at computationally expensive tasks such as modular
+LibTomMath is almost always an order of magnitude faster than the MPI library at computationally expensive tasks such as modular
 exponentiation.  In the grand scheme of ``bignum'' libraries LibTomMath is faster than the average library and usually  
 slower than the best libraries such as GMP and OpenSSL by a small factor.
 
@@ -355,14 +357,31 @@ reader is encouraged to download their own copy of the library to actually be ab
 
 \chapter{Getting Started}
 \section{Library Basics}
-To get the ``ball rolling'' so to speak a primitive data type and a series of primitive algorithms must be established.  First a data
+To begin the design of a multiple precision integer library a primitive data type and a series of primitive algorithms must be established.  A data
 type that will hold the information required to maintain a multiple precision integer must be designed.  With this basic data type of a series
-of low level algorithms for initializing, clearing, growing and clamping integers can be developed to form the basis of the entire
-package of algorithms.
+of low level algorithms for initializing, clearing, growing and optimizing multiple precision integers can be developed to form the basis of 
+the entire library of algorithms.
+
+\section{What is a Multiple Precision Integer?}
+Recall that most programming languages (\textit{in particular C}) only have fixed precision data types that on their own cannot be used
+to represent values larger than their precision alone will allow. The purpose of multiple precision algorithms is to use these fixed precision
+data types to create multiple precision integers which may represent values that are much larger.  
+
+As a well known analogy, school children are taught how to form numbers larger than nine by prepending more radix ten digits.  In the decimal system
+the largest value is only $9$ since the digits may only have values from $0$ to $9$.  However, by concatenating digits together larger numbers 
+may be represented.  Computer based multiple precision arithmetic is essentially the same concept except with a different radix.
+
+What most people probably do not think about explicitly are the various other attributes that describe a multiple precision integer.  For example,
+the integer $154_{10}$ has two immediately obvious properties.  First, the integer is positive, that is the sign of this particular integer 
+is positive as oppose to negative.  Second, the integer has three digits in its representation.  There is an additional property that the integer 
+posesses that does not concern pencil-and-paper arithmetic.  The third property is how many digits are allowed for the integer.  
 
-\section{The mp\_int structure}
-First the data type for storing multiple precision integers must be designed.  This data type must be able to hold information to 
-maintain an array of digits, how many are actually used in the representation and the sign.  The ISO C standard does not provide for 
+The human analogy of this third property is ensuring there is enough space on the paper to right the integer.  Computers must maintain a
+strict control on memory usage with respect to the digits of a multiple precision integer.  These three properties make up what is known
+as a multiple precision integer or mp\_int for short.  
+
+\subsection{The mp\_int structure}
+The mp\_int structure is the ISO C based manifestation of what represents a multiple precision integer.  The ISO C standard does not provide for 
 any such data type but it does provide for making composite data types known as structures.  The following is the structure definition 
 used within LibTomMath.
 
@@ -374,15 +393,25 @@ typedef struct  {
 } mp_int;
 \end{verbatim}
 
-The \textbf{used} parameter denotes how many digits of the array \textbf{dp} are actually being used.  The array 
-\textbf{dp} holds the digits that represent the integer desired.  The \textbf{alloc} parameter denotes how 
+The mp\_int structure can be broken down as follows.
+
+\begin{enumerate}
+\item The \textbf{used} parameter denotes how many digits of the array \textbf{dp} contain the digits used to represent
+a given integer.  The \textbf{used} count must not exceed the \textbf{alloc} count.  
+
+\item The array \textbf{dp} holds the digits that represent the given integer.  It is padded with $\textbf{alloc} - \textbf{used}$ zero
+digits.
+
+\item The \textbf{alloc} parameter denotes how 
 many digits are available in the array to use by functions before it has to increase in size.  When the \textbf{used} count 
-of a result would exceed the \textbf{alloc} count all LibTomMath routines will automatically increase the size of the 
-array to accommodate the precision of the result.  The \textbf{sign} parameter denotes the sign as either zero/positive 
-(\textbf{MP\_ZPOS}) or negative (\textbf{MP\_NEG}).  
+of a result would exceed the \textbf{alloc} count all of the algorithms will automatically increase the size of the 
+array to accommodate the precision of the result.  
+
+\item The \textbf{sign} parameter denotes the sign as either zero/positive (\textbf{MP\_ZPOS}) or negative (\textbf{MP\_NEG}).  
+\end{enumerate}
 
 \section{Argument Passing}
-A convention of arugment passing must be adopted early on in the development of any library.  Making the function prototypes
+A convention of argument passing must be adopted early on in the development of any library.  Making the function prototypes
 consistent will help eliminate many headaches in the future as the library grows to significant complexity.  In LibTomMath the multiple precision 
 integer functions accept parameters from left to right as pointers to mp\_int structures.  That means that the source operands are 
 placed on the left and the destination on the right.   Consider the following examples.
@@ -397,17 +426,18 @@ The left to right order is a fairly natural way to implement the functions since
 functions and make sense of them.  For example, the first function would read ``multiply a and b and store in c''.
 
 Certain libraries (\textit{LIP by Lenstra for instance}) accept parameters the other way around.  That is the destination
-on the left and arguments on the right.  In truth it is entirely a matter of preference.  
+on the left and arguments on the right.  In truth it is entirely a matter of preference.  In the case of LibTomMath the 
+convention from the MPI library has been adopted.  
 
 Another very useful design consideration is whether to allow argument sources to also be a destination.  For example, the
 second example (\textit{mp\_add}) adds $a$ to $b$ and stores in $a$.  This is an important feature to implement since it
 allows the higher up functions to cut down on the number of variables.  However, to implement this feature specific
-care has to be given to ensure the destination is not written before the source is fully read.
+care has to be given to ensure the destination is not modified before the source is fully read.
 
 \section{Return Values}
 A well implemented library, no matter what its purpose, should trap as many runtime errors as possible and return them to the 
-caller.  By catching runtime errors a library can be guaranteed to prevent undefined behaviour within reason.  In a multiple precision 
-library the only errors that are bound to occur are related to inappropriate inputs (\textit{division by zero for instance}) or 
+caller.  By catching runtime errors a library can be guaranteed to prevent undefined behaviour.  In a multiple precision 
+library the only errors that can occur occur are related to inappropriate inputs (\textit{division by zero for instance}) or 
 memory allocation errors.
 
 In LibTomMath any function that can cause a runtime error will return an error as an \textbf{int} data type with one of the 
@@ -424,7 +454,7 @@ following values.
 \end{tabular}
 \end{center}
 
-When an error is detected within a function it should free any memory they allocated and return as soon as possible.  The goal
+When an error is detected within a function it should free any memory it allocated and return as soon as possible.  The goal
 is to leave the system in the same state the system was when the function was called.  Error checking with this style of API is fairly simple.
 
 \begin{verbatim}
@@ -436,7 +466,7 @@ is to leave the system in the same state the system was when the function was ca
 \end{verbatim}
 
 The GMP library uses C style \textit{signals} to flag errors which is of questionable use.  Not all errors are fatal 
-and it is not ideal to force developers to have signal handlers for such cases.
+and it was not deemed ideal by the author of LibTomMath to force developers to have signal handlers for such cases.
 
 \section{Initialization and Clearing}
 The logical starting point when actually writing multiple precision integer functions is the initialization and 
@@ -446,7 +476,7 @@ temporary integers are required.
 Given the basic mp\_int structure an initialization routine must first allocate memory to hold the digits of
 the integer.  Often it is optimal to allocate a sufficiently large pre-set number of digits even considering
 the initial integer will represent zero.  If only a single digit were allocated quite a few re-allocations
-would occur for the majority of inputs.  There exists a tradeoff between how many default digits to allocate
+would occur for the majority of inputs.  There is a tradeoff between how many default digits to allocate
 and how many re-allocations are tolerable.  
 
 If the memory for the digits has been successfully allocated then the rest of the members of the structure must
@@ -480,7 +510,7 @@ the memory required and initialize the integer to a default representation of ze
 
 \textbf{Algorithm mp\_init.}
 The \textbf{MP\_PREC} variable is a simple constant used to dictate minimal precision of allocated integers.  It is ideally at least equal to $32$ but 
-can be any reasonable power of two.  Step one and two allocate the memory and account for it.  If the allocation fails the algorithm returns
+can be any reasonable power of two.  Steps one and two allocate the memory and account for it.  If the allocation fails the algorithm returns
 immediately to signal the failure.  Step three will ensure that all the digits are in the default state of zero.  Finally steps 
 four through six set the default settings of the \textbf{sign}, \textbf{used} and \textbf{alloc} members of the mp\_int structure.
 
@@ -500,7 +530,7 @@ four through six set the default settings of the \textbf{sign}, \textbf{used} an
 024       return MP_MEM;
 025     \}
 026   
-027     /* set the used to zero, allocated digit to the default precision
+027     /* set the used to zero, allocated digits to the default precision
 028      * and sign to positive */
 029     a->used  = 0;
 030     a->alloc = MP_PREC;
@@ -541,9 +571,9 @@ the mp\_clear algorithm.
 \textbf{Algorithm mp\_clear.}
 In steps one and two the memory for the digits are only free'd if they had not been previously released before.  
 This is more of concern for the implementation since it is used to prevent ``double-free'' errors.  It also helps catch
-code errors where mp\_ints are used after being cleared.  Simiarly steps three and four set the 
+code errors where mp\_ints are used after being cleared.  Similarly steps three and four set the 
 \textbf{used} and \textbf{alloc} to known values which would be easy to spot during debugging.  For example, if an mp\_int is expected
-to be non-zero and its \textbf{used} member observed to be zero (\textit{due to being cleared}) then an obvious bug in the code has been
+to be non-zero and its \textbf{used} member is observed to be zero (\textit{due to being cleared}) then an obvious bug in the code has been
 spotted.
 
 \index{bn\_mp\_clear.c}
@@ -653,7 +683,7 @@ input size is known.
 \textbf{Algorithm mp\_init\_size.}
 The value of $v$ is calculated to be at least the requested amount of digits $b$ plus additional padding.  The padding is calculated
 to be at least \textbf{MP\_PREC} digits plus enough digits to make the digit count a multiple of \textbf{MP\_PREC}.  This padding is used to 
-prevent trivial allocations from becomming a bottleneck in the rest of the algorithms that depend on this.
+prevent trivial allocations from becoming a bottleneck in the rest of the algorithms that depend on this.
 
 \index{bn\_mp\_init\_size.c}
 \vspace{+3mm}\begin{small}
@@ -700,9 +730,9 @@ The mp\_init\_copy algorithm will perform this very task.
 \textbf{Input}.   An mp\_int $a$ and $b$\\
 \textbf{Output}.  $a$ is initialized to be a copy of $b$. \\
 \hline \\
-1.  Init $a$.  (\textit{hint: use mp\_init}) \\
+1.  Init $a$.  (\textit{mp\_init}) \\
 2.  If the init of $a$ was unsuccessful return(\textit{MP\_MEM}) \\
-3.  Copy $b$ to $a$.  (\textit{hint: use mp\_copy}) \\
+3.  Copy $b$ to $a$.  (\textit{mp\_copy}) \\
 4.  Return the status of the copy operation. \\
 \hline
 \end{tabular}
@@ -739,7 +769,7 @@ This will initialize \textbf{a} and make it a verbatim copy of the contents of \
 \textbf{a} will have its own memory allocated which means that \textbf{b} may be cleared after the call
 and \textbf{a} will be left intact.  
 
-\subsection{Multiple Integer Initializations}
+\subsection{Multiple Integer Initializations And Clearings}
 Occasionally a function will require a series of mp\_int data types to be made available.  The mp\_init\_multi algorithm
 is provided to simplify such cases.  The purpose of this algorithm is to initialize a variable length array of mp\_int 
 structures at once.  As a result algorithms that require multiple integers only has to use 
@@ -753,10 +783,10 @@ one algorithm to initialize all the mp\_int variables.
 \textbf{Output}.  The array is initialized such that each each mp\_int is ready to use. \\
 \hline \\
 1.  for $n$ from 0 to $k - 1$ do \\
-\hspace{+3mm}1.1.  Initialize the $n$'th mp\_int (\textit{hint: use mp\_init}) \\
+\hspace{+3mm}1.1.  Initialize the $n$'th mp\_int (\textit{mp\_init}) \\
 \hspace{+3mm}1.2.  If initialization failed then do \\
 \hspace{+6mm}1.2.1.  for $j$ from $0$ to $n$ do \\
-\hspace{+9mm}1.2.1.1.  Free the $j$'th mp\_int (\textit{hint: use mp\_clear}) \\
+\hspace{+9mm}1.2.1.1.  Free the $j$'th mp\_int (\textit{mp\_clear}) \\
 \hspace{+6mm}1.2.2.   Return(\textit{MP\_MEM}) \\
 2.  Return(\textit{MP\_OKAY}) \\
 \hline
@@ -770,8 +800,36 @@ The algorithm will initialize the array of mp\_int variables one at a time.  As 
 the previously initialized variables are cleared.  The goal is an ``all or nothing'' initialization which allows for quick recovery from runtime 
 errors.
 
-\subsection{Multiple Integer Clearing}
-Similarly to clear a variable length list of mp\_int structures the mp\_clear\_multi algorithm will be used.
+Similarly to clear a variable length array of mp\_int structures the mp\_clear\_multi algorithm will be used.
+
+Consider the following snippet which demonstrates how to use both routines.
+\begin{small}
+\begin{verbatim}
+#include <tommath.h>
+#include <stdio.h>
+#include <stdlib.h>
+int main(void)
+{
+   mp_int num1, num2, num3;
+   int err;
+   
+   if ((err = mp_init_multi(&num1, &num2, &num3, NULL)) !- MP_OKAY) {
+      printf("Error: %d\n", err);
+      return EXIT_FAILURE;
+   }
+   
+   /* at this point num1/num2/num3 are ready */
+   
+   /* free them */
+   mp_clear_multi(&num1, &num2, &num3, NULL);
+   
+   return EXIT_SUCCESS;
+}
+\end{verbatim}
+\end{small}
+
+Note how both lists are terminated with the \textbf{NULL} variable.  This indicates to the algorithms to stop fetching parameters off
+of the stack.  If it is not present the functions will most likely cause a segmentation fault.  
 
 \index{bn\_mp\_multi.c}
 \vspace{+3mm}\begin{small}
@@ -830,31 +888,7 @@ Similarly to clear a variable length list of mp\_int structures the mp\_clear\_m
 \end{alltt}
 \end{small}
 
-Consider the following snippet which demonstrates how to use both routines.
-\begin{small}
-\begin{verbatim}
-#include <tommath.h>
-#include <stdio.h>
-#include <stdlib.h>
-int main(void)
-{
-   mp_int num1, num2, num3;
-   int err;
-   
-   if ((err = mp_init_multi(&num1, &num2, &num3, NULL)) !- MP_OKAY) {
-      printf("Error: %d\n", err);
-      return EXIT_FAILURE;
-   }
-   
-   /* at this point num1/num2/num3 are ready */
-   
-   /* free them */
-   mp_clear_multi(&num1, &num2, &num3, NULL);
-   
-   return EXIT_SUCCESS;
-}
-\end{verbatim}
-\end{small}
+Both routines are implemented in the same source file since they are typically used in conjunction with each other.  
 
 \section{Maintenance}
 A small useful collection of mp\_int maintenance functions will also prove useful.  
@@ -892,7 +926,7 @@ Step one will prevent a re-allocation from being performed if it was not require
 from growing excessively in code that erroneously calls mp\_grow.  Similar to mp\_init\_size the requested digit count
 is padded to provide more digits than requested.  
 
-In step four it is assumed that the reallocation leaves the lower $a.alloc$ digits intact.  Much akin to how the 
+In step four it is assumed that the reallocation leaves the lower $a.alloc$ digits intact.  This is much akin to how the 
 \textit{realloc} function from the standard C library works.  Since the newly allocated digits are assumed to contain
 undefined values they are also initially zeroed.
 
@@ -938,12 +972,12 @@ old \textbf{alloc} limit to make sure the integer is in a known state.
 \subsection{Clamping Excess Digits}
 When a function anticipates a result will be $n$ digits it is simpler to assume this is true within the body of 
 the function.  For example, a multiplication of a $i$ digit number by a $j$ digit produces a result of at most 
-$i + j + 1$ digits.  It is entirely possible that the result is $i + j$ though, with no final carry into the last 
-position.  However, suppose the destination had to be first expanded (\textit{via mp\_grow}) to accomodate $i + j$
+$i + j$ digits.  It is entirely possible that the result is $i + j - 1$ though, with no final carry into the last 
+position.  However, suppose the destination had to be first expanded (\textit{via mp\_grow}) to accomodate $i + j - 1$
 digits than further expanded to accomodate the final carry.  That would be a considerable waste of time since heap
 operations are relatively slow.
 
-The ideal solution is to always assume the result is $i + j + 1$ and fix up the \textbf{used} count after the function
+The ideal solution is to always assume the result is $i + j$ and fix up the \textbf{used} count after the function
 terminates.  This way a single heap operation (\textit{at most}) is required.  However, if the result was not checked
 there would be an excess high order zero digit.  
 
@@ -974,8 +1008,8 @@ number which means that if the \textbf{used} count is decremented to zero the si
 \end{figure}
 
 \textbf{Algorithm mp\_clamp.}
-As can be expected this algorithm is very simple.  The loop on step one is indended to be iterate only once or twice at
-the most.  For example, for cases where there is not a carry to fill the last position.  Step two fixes the sign for 
+As can be expected this algorithm is very simple.  The loop on step one is expected to iterate only once or twice at
+the most.  For example, this will happen in cases where there is not a carry to fill the last position.  Step two fixes the sign for 
 when all of the digits are zero to ensure that the mp\_int is valid at all times.
 
 \index{bn\_mp\_clamp.c}
@@ -1028,7 +1062,7 @@ $\left [ 1 \right ]$ & Give an example of when the algorithm  mp\_init\_copy mig
 
 \chapter{Basic Operations}
 \section{Copying an Integer}
-After the various house-keeping routines are in place, simpl algorithms can be designed to take advantage of them.  Being able
+After the various house-keeping routines are in place, simple algorithms can be designed to take advantage of them.  Being able
 to make a verbatim copy of an integer is a very useful function to have.  To copy an integer the mp\_copy algorithm will be used.
 
 \newpage\begin{figure}[here]
@@ -1040,7 +1074,7 @@ to make a verbatim copy of an integer is a very useful function to have.  To cop
 \hline \\
 1.  Check if $a$ and $b$ point to the same location in memory. \\
 2.  If true then return(\textit{MP\_OKAY}). \\
-3.  If $b.alloc < a.used$ then grow $b$ to $a.used$ digits.  (\textit{hint: use mp\_grow}) \\
+3.  If $b.alloc < a.used$ then grow $b$ to $a.used$ digits.  (\textit{mp\_grow}) \\
 4.  If failed to grow then return(\textit{MP\_MEM}). \\
 5.  for $n$ from 0 to $a.used - 1$ do \\
 \hspace{3mm}5.1  $b_{n} \leftarrow a_{n}$ \\
@@ -1064,7 +1098,7 @@ member of $a$ but a memory re-allocation is only required if the \textbf{alloc} 
 prevents trivial memory reallocations.
 
 Step 5 copies the digits from $a$ to $b$ while step 6 ensures that if initially $\vert b \vert > \vert a \vert$,
-the leading digits of $b$ will be zeroed.  Finally steps 7 and 8 copies the \textbf{used} and \textbf{sign} members over 
+the more significant digits of $b$ will be zeroed.  Finally steps 7 and 8 copies the \textbf{used} and \textbf{sign} members over 
 which completes the copy operation.
 
 \index{bn\_mp\_copy.c}
@@ -1080,7 +1114,7 @@ which completes the copy operation.
 021     int     res, n;
 022   
 023     /* if dst == src do nothing */
-024     if (a == b || a->dp == b->dp) \{
+024     if (a == b) \{
 025       return MP_OKAY;
 026     \}
 027   
@@ -1119,7 +1153,7 @@ make sure there is enough room.  If not enough space is available it returns the
 intact.
 
 The inner loop of the copy operation is contained between lines 34 and 50.  Many LibTomMath routines are designed with this source code style
-in mind, making aliases to shorten lengthy pointers (\textit{see line 38 and 39}) for rapid to use.  Also the
+in mind, making aliases to shorten lengthy pointers (\textit{see line 38 and 39}) for rapid use.  Also the
 use of nested braces creates a simple way to denote various portions of code that reside on various work levels.  Here, the copy loop is at the 
 $O(n)$ level.  
 
@@ -1179,7 +1213,7 @@ the absolute value of an mp\_int.
 \textbf{Input}.   An mp\_int $a$ \\
 \textbf{Output}.  Computes $b = \vert a \vert$ \\
 \hline \\
-1.  Copy $a$ to $b$.  (\textit{hint: use mp\_copy}) \\
+1.  Copy $a$ to $b$.  (\textit{mp\_copy}) \\
 2.  If the copy failed return(\textit{MP\_MEM}). \\
 3.  $b.sign \leftarrow MP\_ZPOS$ \\
 4.  Return(\textit{MP\_OKAY}) \\
@@ -1226,7 +1260,7 @@ the negative of an mp\_int input.
 \textbf{Input}.   An mp\_int $a$ \\
 \textbf{Output}.  Computes $b = -a$ \\
 \hline \\
-1.  Copy $a$ to $b$.  (\textit{hint: use mp\_copy}) \\
+1.  Copy $a$ to $b$.  (\textit{mp\_copy}) \\
 2.  If the copy failed return(\textit{MP\_MEM}). \\
 3.  If $a.sign = MP\_ZPOS$ then do \\
 \hspace{3mm}3.1  $b.sign = MP\_NEG$. \\
@@ -1273,7 +1307,7 @@ Often a mp\_int must be set to a relatively small value such as $1$ or $2$.  For
 \textbf{Input}.   An mp\_int $a$ and a digit $b$ \\
 \textbf{Output}.  Make $a$ equivalent to $b$ \\
 \hline \\
-1.  Zero $a$ (\textit{hint: use mp\_zero}). \\
+1.  Zero $a$ (\textit{mp\_zero}). \\
 2.  $a_0 \leftarrow b \mbox{ (mod }\beta\mbox{)}$ \\
 3.  $a.used \leftarrow  \left \lbrace \begin{array}{ll}
                               1 &  \mbox{if }a_0 > 0 \\
@@ -1306,16 +1340,14 @@ single digit is set (\textit{modulo $\beta$}) and the \textbf{used} count is adj
 \end{alltt}
 \end{small}
 
-Line 21 calls mp\_zero() to clear the mp\_int and reset the sign.  Line 22 actually copies digit 
+Line 21 calls mp\_zero() to clear the mp\_int and reset the sign.  Line 22 copies the digit 
 into the least significant location.  Note the usage of a new constant \textbf{MP\_MASK}.  This constant is used to quickly
-reduce an integer modulo $\beta$.  Since $\beta = 2^k$ it suffices to perform a binary AND with $MP\_MASK = 2^k - 1$ to perform
-the reduction.  Finally line 23 will set the \textbf{used} member with respect to the digit actually set. This function 
-will always make the integer positive.
+reduce an integer modulo $\beta$.  Since $\beta$ is of the form $2^k$ for any suitable $k$ it suffices to perform a binary AND with 
+$MP\_MASK = 2^k - 1$ to perform the reduction.  Finally line 23 will set the \textbf{used} member with respect to the 
+digit actually set. This function will always make the integer positive.
 
 One important limitation of this function is that it will only set one digit.  The size of a digit is not fixed, meaning source that uses 
-this function should take that into account.  The define \textbf{DIGIT\_BIT} in ``tommath.h'' 
-defines how many bits per digit are available.  Generally at least seven bits are guaranteed to be available per 
-digit.  This means that trivially small constants can be set using this function.
+this function should take that into account.  Meaning that only trivially small constants can be set using this function.
 
 \subsection{Setting Large Constants}
 To overcome the limitations of the mp\_set algorithm the mp\_set\_int algorithm is provided.  It accepts a ``long''
@@ -1328,13 +1360,13 @@ data type as input and will always treat it as a 32-bit integer.
 \textbf{Input}.   An mp\_int $a$ and a ``long'' integer $b$ \\
 \textbf{Output}.  Make $a$ equivalent to $b$ \\
 \hline \\
-1.  Zero $a$ (\textit{hint: use mp\_zero}) \\
+1.  Zero $a$ (\textit{mp\_zero}) \\
 2.  for $n$ from 0 to 7 do \\
-\hspace{3mm}2.1  $a \leftarrow a \cdot 16$ (\textit{hint: use mp\_mul2d}) \\
+\hspace{3mm}2.1  $a \leftarrow a \cdot 16$ (\textit{mp\_mul2d}) \\
 \hspace{3mm}2.2  $u \leftarrow \lfloor b / 2^{4(7 - n)} \rfloor \mbox{ (mod }16\mbox{)}$\\
 \hspace{3mm}2.3  $a_0 \leftarrow a_0 + u$ \\
-\hspace{3mm}2.4  $a.used \leftarrow a.used + \lfloor 32 / lg(\beta) \rfloor + 1$ \\
-3.  Clamp excess used digits (\textit{hint: use mp\_clamp}) \\
+\hspace{3mm}2.4  $a.used \leftarrow a.used + 1$ \\
+3.  Clamp excess used digits (\textit{mp\_clamp}) \\
 \hline
 \end{tabular}
 \end{center}
@@ -1343,9 +1375,9 @@ data type as input and will always treat it as a 32-bit integer.
 
 \textbf{Algorithm mp\_set\_int.}
 The algorithm performs eight iterations of a simple loop where in each iteration four bits from the source are added to the 
-mp\_int.  Step 2.1 will multiply the current result by sixteen making room for four more bits.  In step 2.2 the
-next four bits from the source are extracted.  The four bits are added to the mp\_int and the \textbf{used} digit count is 
-incremented.  The \textbf{used} digit counter is incremented since if any of the leading digits were zero the mp\_int would have
+mp\_int.  Step 2.1 will multiply the current result by sixteen making room for four more bits in the less significant positions.  In step 2.2 the
+next four bits from the source are extracted and are added to the mp\_int. The \textbf{used} digit count is 
+incremented to reflect the addition.  The \textbf{used} digit counter is incremented since if any of the leading digits were zero the mp\_int would have
 zero digits used and the newly added four bits would be ignored.
 
 Excess zero digits are trimmed in steps 2.1 and 3 by using higher level algorithms mp\_mul2d and mp\_clamp.
@@ -1377,7 +1409,7 @@ Excess zero digits are trimmed in steps 2.1 and 3 by using higher level algorith
 035       b <<= 4;
 036   
 037       /* ensure that digits are not clamped off */
-038       a->used += 32 / DIGIT_BIT + 2;
+038       a->used += 1;
 039     \}
 040     mp_clamp (a);
 041     return MP_OKAY;
@@ -1443,7 +1475,7 @@ Obviously if the digit counts differ there would be an imaginary zero digit in t
 If both have the same number of digits than the actual digits themselves must be compared starting at the leading digit.  
 
 By step three both inputs must have the same number of digits so its safe to start from either $a.used - 1$ or $b.used - 1$ and count down to
-the zero'th digit.  If after all of the digits have been compared and no difference found the algorithm simply returns \textbf{MP\_EQ}.
+the zero'th digit.  If after all of the digits have been compared, no difference is found, the algorithm returns \textbf{MP\_EQ}.
 
 \index{bn\_mp\_cmp\_mag.c}
 \vspace{+3mm}\begin{small}
@@ -1483,14 +1515,14 @@ the zero'th digit.  If after all of the digits have been compared and no differe
 
 The two if statements on lines 24 and 28 compare the number of digits in the two inputs.  These two are performed before all of the digits
 are compared since it is a very cheap test to perform and can potentially save considerable time.  The implementation given is also not valid 
-without those two statements.  $b.alloc$ may be smaller than $a.used$, meaning that undefined values will be read from $b$ passed the end of the 
+without those two statements.  $b.alloc$ may be smaller than $a.used$, meaning that undefined values will be read from $b$ past the end of the 
 array of digits.
 
 \subsection{Signed Comparisons}
 Comparing with sign considerations is also fairly critical in several routines (\textit{division for example}).  Based on an unsigned magnitude 
 comparison a trivial signed comparison algorithm can be written.
 
-\newpage\begin{figure}[here]
+\begin{figure}[here]
 \begin{center}
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_cmp}. \\
@@ -1500,7 +1532,7 @@ comparison a trivial signed comparison algorithm can be written.
 1.  if $a.sign = MP\_NEG$ and $b.sign = MP\_ZPOS$ then return(\textit{MP\_LT}) \\
 2.  if $a.sign = MP\_ZPOS$ and $b.sign = MP\_NEG$ then return(\textit{MP\_GT}) \\
 3.  if $a.sign = MP\_NEG$ then \\
-\hspace{+3mm}3.1  Return the unsigned comparison of $b$ and $a$ (\textit{hint: use mp\_cmp\_mag}) \\
+\hspace{+3mm}3.1  Return the unsigned comparison of $b$ and $a$ (\textit{mp\_cmp\_mag}) \\
 4   Otherwise \\
 \hspace{+3mm}4.1  Return the unsigned comparison of $a$ and $b$ \\
 \hline
@@ -1564,10 +1596,10 @@ $\left [ 1 \right ]$ & Suggest a simple method to speed up the implementation of
 
 \chapter{Basic Arithmetic}
 \section{Building Blocks}
-At this point algorithms for initialization, de-initialization, zeroing, copying, comparing and setting small constants have been 
-established.  The next logical set of algorithms to develop are the addition, subtraction and digit movement algorithms.  These 
-algorithms make use of the lower level algorithms and are the cruicial building block for the multipliers.  It is very important that these 
-algorithms are highly optimized.  On their own they are simple $O(n)$ algorithms but they can be called from higher level algorithms 
+At this point algorithms for initialization, clearing, zeroing, copying, comparing and setting small constants have been 
+established.  The next logical set of algorithms to develop are addition, subtraction and digit shifting algorithms.  These 
+algorithms make use of the lower level algorithms and are the cruicial building block for the multiplication algorithms.  It is very important 
+that these algorithms are highly optimized.  On their own they are simple $O(n)$ algorithms but they can be called from higher level algorithms 
 which easily places them at $O(n^2)$ or even $O(n^3)$ work levels.  
 
 All nine algorithms within this chapter make use of the logical bit shift operations denoted by $<<$ and $>>$ for left and right 
@@ -1614,7 +1646,7 @@ Historically that convention stems from the MPI library where ``s\_'' stood for 
 \hspace{+3mm}2.1  $min \leftarrow a.used$ \\
 \hspace{+3mm}2.2  $max \leftarrow b.used$ \\
 \hspace{+3mm}2.3  $x   \leftarrow b$ \\
-3.  If $c.alloc < max + 1$ then grow $c$ to hold at least $max + 1$ digits (\textit{hint: use mp\_grow}) \\
+3.  If $c.alloc < max + 1$ then grow $c$ to hold at least $max + 1$ digits (\textit{mp\_grow}) \\
 4.  If failed to grow $c$ return(\textit{MP\_MEM}) \\
 5.  $oldused \leftarrow c.used$ \\
 6.  $c.used \leftarrow max + 1$ \\
@@ -1632,7 +1664,7 @@ Historically that convention stems from the MPI library where ``s\_'' stood for 
 11.  if $olduse > max$ then \\
 \hspace{+3mm}11.1  for $n$ from $max + 1$ to $olduse - 1$ do \\
 \hspace{+6mm}11.1.1  $c_n \leftarrow 0$ \\
-12.  Clamp excess digits in $c$.  (\textit{hint: use mp\_clamp}) \\
+12.  Clamp excess digits in $c$.  (\textit{mp\_clamp}) \\
 13.  Return(\textit{MP\_OKAY}) \\
 \hline
 \end{tabular}
@@ -1642,32 +1674,33 @@ Historically that convention stems from the MPI library where ``s\_'' stood for 
 \end{figure}
 
 \textbf{Algorithm s\_mp\_add.}
-This algorithm is loosely based on algorithm 14.7 of \cite[pp. 594]{HAC} but has been extended to allow the inputs to have different magnitudes.  
-Coincidentally the description of algorithm A in \cite[pp. 266]{TAOCPV2} shares the same flaw as that from \cite{HAC}.  Even the MIX pseudo 
-machine code presented  \cite[pp. 266-267]{TAOCPV2} is incapable of handling inputs which are of different magnitudes.
+This algorithm is loosely based on algorithm 14.7 of HAC \cite[pp. 594]{HAC} but has been extended to allow the inputs to have different magnitudes.  
+Coincidentally the description of algorithm A in Knuth \cite[pp. 266]{TAOCPV2} shares the same deficiency as the algorithm from \cite{HAC}.  Even the 
+MIX pseudo  machine code presented by Knuth \cite[pp. 266-267]{TAOCPV2} is incapable of handling inputs which are of different magnitudes.
 
 Steps 1 and 2 will sort the two inputs based on their \textbf{used} digit count.  This allows the inputs to have varying magnitudes which not 
-only makes it more efficient than the trivial algorithm presented in the other references but more flexible.  The variable $min$ is given the lowest 
+only makes it more efficient than the trivial algorithm presented in the references but more flexible.  The variable $min$ is given the lowest 
 digit count while $max$ is given the highest digit count.  If both inputs have the same \textbf{used} digit count both $min$ and $max$ are 
-set to the same.  The variable $x$ is an \textit{alias} for the largest input and not meant to be a copy of it.  After the inputs are sorted steps 
-3 and 4 will ensure that the destination $c$ can accommodate the result.  The old \textbf{used} count from $c$ is copied to $oldused$ and the 
-new count is set to $max + 1$.  
+set to the same value.  The variable $x$ is an \textit{alias} for the largest input and not meant to be a copy of it.  After the inputs are sorted, 
+steps 3 and 4 will ensure that the destination $c$ can accommodate the result.  The old \textbf{used} count from $c$ is copied to 
+$oldused$ so that excess digits can be cleared later, and the new \textbf{used} count is set to $max+1$, so that a carry from the most significant 
+word can be handled.
 
-At step 7 the carry variable $u$ is set to zero and the first leg of the addition loop can begin.  The first step of the loop (\textit{8.1}) adds
+At step 7 the carry variable $u$ is set to zero and the first part of the addition loop can begin.  The first step of the loop (\textit{8.1}) adds
 digits from the two inputs together along with the carry variable $u$.  The following step extracts the carry bit by shifting the result of the
-preceding step right $lg(\beta)$ positions.  The shift to extract the carry is similar to how carry extraction works with decimal addition.
+preceding step right by $lg(\beta)$ positions.  The shift to extract the carry is similar to how carry extraction works with decimal addition.
 
 Consider adding $77$ to $65$, the first addition of the first column is $7 + 5$ which produces the result $12$.  The trailing digit of the result
 is $2 \equiv 12 \mbox{ (mod }10\mbox{)}$ and the carry is found by dividing (\textit{and ignoring the remainder}) $12$ by the radix or in this case $10$.  The
-division and multiplication of $10$ is simply a logical shift right or left respectively of the digits.  In otherwords the carry can be extracted
+division and multiplication of $10$ is simply a logical right or left shift, respectively, of the digits.  In otherwords the carry can be extracted
 by shifting one digit to the right.
 
 Note that $lg()$ is simply the base two logarithm such that $lg(2^k) = k$.  This implies that $lg(\beta)$ is the number of bits in a radix-$\beta$ 
-digit.  Therefore, a logical shift right of the single digit by $lg(\beta)$ will extract the carry.  The final step of the  loop reduces the digit 
+digit.  Therefore, a logical shift right of the summand by $lg(\beta)$ will extract the carry.  The final step of the loop reduces the digit 
 modulo the radix $\beta$ to ensure it is in range.
 
 After step 8 the smallest input (\textit{or both if they are the same magnitude}) has been exhausted.  Step 9 decides whether
-the inputs were of equal magnitude.  If not than another loop similar to that in step 8 must be executed.  The loop at step
+the inputs were of equal magnitude.  If not than another loop similar to that in step 8, must be executed.  The loop at step
 number 9.1 differs from the previous loop since it only adds the mp\_int $x$ along with the carry.  
 
 Step 10 finishes the addition phase by copying the final carry to the highest location in the result $c_{max}$.  Step 11 ensures that 
@@ -1710,79 +1743,78 @@ leading digits that were originally present in $c$ are cleared.  Finally excess 
 045     olduse = c->used;
 046     c->used = max + 1;
 047   
-048     /* set the carry to zero */
-049     \{
-050       register mp_digit u, *tmpa, *tmpb, *tmpc;
-051       register int i;
-052   
-053       /* alias for digit pointers */
-054   
-055       /* first input */
-056       tmpa = a->dp;
-057   
-058       /* second input */
-059       tmpb = b->dp;
-060   
-061       /* destination */
-062       tmpc = c->dp;
-063   
-064       /* zero the carry */
-065       u = 0;
-066       for (i = 0; i < min; i++) \{
-067         /* Compute the sum at one digit, T[i] = A[i] + B[i] + U */
-068         *tmpc = *tmpa++ + *tmpb++ + u;
-069   
-070         /* U = carry bit of T[i] */
-071         u = *tmpc >> ((mp_digit)DIGIT_BIT);
-072   
-073         /* take away carry bit from T[i] */
-074         *tmpc++ &= MP_MASK;
-075       \}
-076   
-077       /* now copy higher words if any, that is in A+B 
-078        * if A or B has more digits add those in 
-079        */
-080       if (min != max) \{
-081         for (; i < max; i++) \{
-082           /* T[i] = X[i] + U */
-083           *tmpc = x->dp[i] + u;
-084   
-085           /* U = carry bit of T[i] */
-086           u = *tmpc >> ((mp_digit)DIGIT_BIT);
-087   
-088           /* take away carry bit from T[i] */
-089           *tmpc++ &= MP_MASK;
-090         \}
-091       \}
-092   
-093       /* add carry */
-094       *tmpc++ = u;
-095   
-096       /* clear digits above oldused */
-097       for (i = c->used; i < olduse; i++) \{
-098         *tmpc++ = 0;
-099       \}
-100     \}
-101   
-102     mp_clamp (c);
-103     return MP_OKAY;
-104   \}
+048     \{
+049       register mp_digit u, *tmpa, *tmpb, *tmpc;
+050       register int i;
+051   
+052       /* alias for digit pointers */
+053   
+054       /* first input */
+055       tmpa = a->dp;
+056   
+057       /* second input */
+058       tmpb = b->dp;
+059   
+060       /* destination */
+061       tmpc = c->dp;
+062   
+063       /* zero the carry */
+064       u = 0;
+065       for (i = 0; i < min; i++) \{
+066         /* Compute the sum at one digit, T[i] = A[i] + B[i] + U */
+067         *tmpc = *tmpa++ + *tmpb++ + u;
+068   
+069         /* U = carry bit of T[i] */
+070         u = *tmpc >> ((mp_digit)DIGIT_BIT);
+071   
+072         /* take away carry bit from T[i] */
+073         *tmpc++ &= MP_MASK;
+074       \}
+075   
+076       /* now copy higher words if any, that is in A+B 
+077        * if A or B has more digits add those in 
+078        */
+079       if (min != max) \{
+080         for (; i < max; i++) \{
+081           /* T[i] = X[i] + U */
+082           *tmpc = x->dp[i] + u;
+083   
+084           /* U = carry bit of T[i] */
+085           u = *tmpc >> ((mp_digit)DIGIT_BIT);
+086   
+087           /* take away carry bit from T[i] */
+088           *tmpc++ &= MP_MASK;
+089         \}
+090       \}
+091   
+092       /* add carry */
+093       *tmpc++ = u;
+094   
+095       /* clear digits above oldused */
+096       for (i = c->used; i < olduse; i++) \{
+097         *tmpc++ = 0;
+098       \}
+099     \}
+100   
+101     mp_clamp (c);
+102     return MP_OKAY;
+103   \}
 \end{alltt}
 \end{small}
 
-Lines 27 to 35 perform the initial sorting of the inputs and determine the $min$ and $max$ variables.  Note that $x$ is pointer to a 
+Lines 27 to 35 perform the initial sorting of the inputs and determine the $min$ and $max$ variables.  Note that $x$ is a pointer to a 
 mp\_int assigned to the largest input, in effect it is a local alias.  Lines 37 to 42 ensure that the destination is grown to 
 accomodate the result of the addition. 
 
-Similar to the implementation of mp\_copy this function uses the braced code and local aliases coding style.  The three aliases on 
-lines 56, 59 and 62 are the for the two inputs and destination respectively.  These aliases are used to ensure the
+Similar to the implementation of mp\_copy this function uses the braced code and local aliases coding style.  The three aliases that are on 
+lines 55, 58 and 61 represent the two inputs and destination variables respectively.  These aliases are used to ensure the
 compiler does not have to dereference $a$, $b$ or $c$ (respectively) to access the digits of the respective mp\_int.
 
-The initial carry $u$ is cleared on line 65, note that $u$ is of type mp\_digit which ensures type compatibility within the 
-implementation.  The initial addition loop begins on line 66 and ends on line 75.  Similarly the conditional addition loop
-begins on line 81 and ends on line 90.  The addition is finished with the final carry being stored in $tmpc$ on line 94.  
-Note the ``++'' operator on the same line.  After line 94 $tmpc$ will point to the $c.used$'th digit of the mp\_int $c$.  This is useful
-for the next loop on lines 97 to 99 which set any old upper digits to zero.
+The initial carry $u$ is cleared on line 64, note that $u$ is of type mp\_digit which ensures type compatibility within the 
+implementation.  The initial addition loop begins on line 65 and ends on line 74.  Similarly the conditional addition loop
+begins on line 80 and ends on line 90.  The addition is finished with the final carry being stored in $tmpc$ on line 93.  
+Note the ``++'' operator on the same line.  After line 93 $tmpc$ will point to the $c.used$'th digit of the mp\_int $c$.  This is useful
+for the next loop on lines 96 to 99 which set any old upper digits to zero.
 
 \subsection{Low Level Subtraction}
 The low level unsigned subtraction algorithm is very similar to the low level unsigned addition algorithm.  The principle difference is that the
@@ -1792,8 +1824,12 @@ This algorithm as will be shown can be used to create functional signed addition
 
 
 For this algorithm a new variable is required to make the description simpler.  Recall from section 1.3.1 that a mp\_digit must be able to represent
-the range $0 \le x < 2\beta$.  It is allowable that a mp\_digit represent a larger range of values.  For this algorithm we will assume that
-the variable $\gamma$ represents the number of bits available in a mp\_digit (\textit{this implies $2^{\gamma} > \beta$}).
+the range $0 \le x < 2\beta$ for the algorithms to work correctly.  However, it is allowable that a mp\_digit represent a larger range of values.  For 
+this algorithm we will assume that the variable $\gamma$ represents the number of bits available in a 
+mp\_digit (\textit{this implies $2^{\gamma} > \beta$}).  
+
+For example, the default for LibTomMath is to use a ``unsigned long'' for the mp\_digit ``type'' while $\beta = 2^{28}$.  In ISO C an ``unsigned long''
+data type must be able to represent $0 \le x < 2^{32}$ meaning that in this case $\gamma = 32$.
 
 \newpage\begin{figure}[!here]
 \begin{center}
@@ -1805,7 +1841,7 @@ the variable $\gamma$ represents the number of bits available in a mp\_digit (\t
 \hline \\
 1.  $min \leftarrow b.used$ \\
 2.  $max \leftarrow a.used$ \\
-3.  If $c.alloc < max$ then grow $c$ to hold at least $max$ digits.  (\textit{hint: use mp\_grow}) \\
+3.  If $c.alloc < max$ then grow $c$ to hold at least $max$ digits.  (\textit{mp\_grow}) \\
 4.  If the reallocation failed return(\textit{MP\_MEM}). \\
 5.  $oldused \leftarrow c.used$ \\ 
 6.  $c.used \leftarrow max$ \\
@@ -1822,7 +1858,7 @@ the variable $\gamma$ represents the number of bits available in a mp\_digit (\t
 10. if $oldused > max$ then do \\
 \hspace{3mm}10.1  for $n$ from $max$ to $oldused - 1$ do \\
 \hspace{6mm}10.1.1  $c_n \leftarrow 0$ \\
-11. Clamp excess digits of $c$.  (\textit{hint: use mp\_clamp}). \\
+11. Clamp excess digits of $c$.  (\textit{mp\_clamp}). \\
 12. Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
@@ -1839,21 +1875,22 @@ of the algorithm s\_mp\_add both other references lack discussion concerning var
 
 The initial sorting of the inputs is trivial in this algorithm since $a$ is guaranteed to have at least the same magnitude of $b$.  Steps 1 and 2 
 set the $min$ and $max$ variables.  Unlike the addition routine there is guaranteed to be no carry which means that the final result can be at 
-most $max$ digits in length as oppose to $max + 1$.  Similar to the addition algorithm the \textbf{used} count of $c$ is copied locally and 
+most $max$ digits in length as opposed to $max + 1$.  Similar to the addition algorithm the \textbf{used} count of $c$ is copied locally and 
 set to the maximal count for the operation.
 
 The subtraction loop that begins on step 8 is essentially the same as the addition loop of algorithm s\_mp\_add except single precision 
-subtraction is used instead.  Note the use of the $\gamma$ variable to extract the carry within the subtraction loops.  Under the assumption
-that two's complement single precision arithmetic is used this will successfully extract the carry.  
+subtraction is used instead.  Note the use of the $\gamma$ variable to extract the carry (\textit{also known as the borrow}) within the subtraction 
+loops.  Under the assumption that two's complement single precision arithmetic is used this will successfully extract the desired carry.  
 
-For example, consider subtracting $0101_2$ from
-$0100_2$ where $\gamma = 4$.  The least significant bit will force a carry upwards to the third bit which will be set to zero after the borrow.  After
-the very first bit has been subtracted $4 - 1 \equiv 0011_2$ will remain,  When the third bit of $0101_2$ is subtracted from the result it will cause
-another carry.  In this case though the carry will be forced to propagate all the way to the most significant bit.  
+For example, consider subtracting $0101_2$ from $0100_2$ where $\gamma = 4$ and $\beta = 2$.  The least significant bit will force a carry upwards to 
+the third bit which will be set to zero after the borrow.  After the very first bit has been subtracted $4 - 1 \equiv 0011_2$ will remain,  When the 
+third bit of $0101_2$ is subtracted from the result it will cause another carry.  In this case though the carry will be forced to propagate all the 
+way to the most significant bit.  
 
-Recall that $\beta < 2^{\gamma}$.  This means that if a carry does occur it will propagate all the way to the most significant bit.  Therefore a single
-logical shift right by $\gamma - 1$ positions is sufficient to extract the carry.  This method of carry extraction may seem awkward but the reason for 
-it becomes apparent when the implementation is discussed.  
+Recall that $\beta < 2^{\gamma}$.  This means that if a carry does occur just before the $lg(\beta)$'th bit it will propagate all the way to the most 
+significant bit.  Thus, the high order bits of the mp\_digit that are not part of the actual digit will either be all zero, or all one. All that
+is needed is a single zero or one bit for the carry.  Therefore a single logical shift right by $\gamma - 1$ positions is sufficient to extract the 
+carry.  This method of carry extraction may seem awkward but the reason for it becomes apparent when the implementation is discussed.  
 
 If $b$ has a smaller magnitude than $a$ then step 9 will force the carry and copy operation to propagate through the larger input $a$ into $c$.  Step
 10 will ensure that any leading digits of $c$ above the $max$'th position are zeroed.
@@ -1883,71 +1920,71 @@ If $b$ has a smaller magnitude than $a$ then step 9 will force the carry and cop
 033     olduse = c->used;
 034     c->used = max;
 035   
-036     /* sub digits from lower part */
-037     \{
-038       register mp_digit u, *tmpa, *tmpb, *tmpc;
-039       register int i;
-040   
-041       /* alias for digit pointers */
-042       tmpa = a->dp;
-043       tmpb = b->dp;
-044       tmpc = c->dp;
-045   
-046       /* set carry to zero */
-047       u = 0;
-048       for (i = 0; i < min; i++) \{
-049         /* T[i] = A[i] - B[i] - U */
-050         *tmpc = *tmpa++ - *tmpb++ - u;
-051   
-052         /* U = carry bit of T[i]
-053          * Note this saves performing an AND operation since
-054          * if a carry does occur it will propagate all the way to the
-055          * MSB.  As a result a single shift is required to get the carry
-056          */
-057         u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
-058   
-059         /* Clear carry from T[i] */
-060         *tmpc++ &= MP_MASK;
-061       \}
-062   
-063       /* now copy higher words if any, e.g. if A has more digits than B  */
-064       for (; i < max; i++) \{
-065         /* T[i] = A[i] - U */
-066         *tmpc = *tmpa++ - u;
-067   
-068         /* U = carry bit of T[i] */
-069         u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
-070   
-071         /* Clear carry from T[i] */
-072         *tmpc++ &= MP_MASK;
-073       \}
-074   
-075       /* clear digits above used (since we may not have grown result above) */
+036     \{
+037       register mp_digit u, *tmpa, *tmpb, *tmpc;
+038       register int i;
+039   
+040       /* alias for digit pointers */
+041       tmpa = a->dp;
+042       tmpb = b->dp;
+043       tmpc = c->dp;
+044   
+045       /* set carry to zero */
+046       u = 0;
+047       for (i = 0; i < min; i++) \{
+048         /* T[i] = A[i] - B[i] - U */
+049         *tmpc = *tmpa++ - *tmpb++ - u;
+050   
+051         /* U = carry bit of T[i]
+052          * Note this saves performing an AND operation since
+053          * if a carry does occur it will propagate all the way to the
+054          * MSB.  As a result a single shift is enough to get the carry
+055          */
+056         u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
+057   
+058         /* Clear carry from T[i] */
+059         *tmpc++ &= MP_MASK;
+060       \}
+061   
+062       /* now copy higher words if any, e.g. if A has more digits than B  */
+063       for (; i < max; i++) \{
+064         /* T[i] = A[i] - U */
+065         *tmpc = *tmpa++ - u;
+066   
+067         /* U = carry bit of T[i] */
+068         u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1));
+069   
+070         /* Clear carry from T[i] */
+071         *tmpc++ &= MP_MASK;
+072       \}
+073   
+074       /* clear digits above used (since we may not have grown result above) */
       
-076       for (i = c->used; i < olduse; i++) \{
-077         *tmpc++ = 0;
-078       \}
-079     \}
-080   
-081     mp_clamp (c);
-082     return MP_OKAY;
-083   \}
+075       for (i = c->used; i < olduse; i++) \{
+076         *tmpc++ = 0;
+077       \}
+078     \}
+079   
+080     mp_clamp (c);
+081     return MP_OKAY;
+082   \}
+083   
 \end{alltt}
 \end{small}
 
-Line 24 and 25 perform the initial hardcoded sorting.  In reality they are only aliases and are only used to make the source easier to 
-read.  Again the pointer alias optimization is used within this algorithm.  Lines 42, 43 and 44 initialize the aliases for 
+Line 24 and 25 perform the initial hardcoded sorting of the inputs.  In reality the $min$ and $max$ variables are only aliases and are only 
+used to make the source code easier to read.  Again the pointer alias optimization is used within this algorithm.  Lines 41, 42 and 43 initialize the aliases for 
 $a$, $b$ and $c$ respectively.
 
-The first subtraction loop occurs on lines 47 through 61.  The theory behind the subtraction loop is exactly the same as that for
+The first subtraction loop occurs on lines 46 through 60.  The theory behind the subtraction loop is exactly the same as that for
 the addition loop.  As remarked earlier there is an implementation reason for using the ``awkward'' method of extracting the carry 
-(\textit{see line 57}).  The traditional method for extracting the carry would be to shift by $lg(\beta)$ positions and logically AND 
+(\textit{see line 56}).  The traditional method for extracting the carry would be to shift by $lg(\beta)$ positions and logically AND 
 the least significant bit.  The AND operation is required because all of the bits above the $\lg(\beta)$'th bit will be set to one after a carry
 occurs from subtraction.  This carry extraction requires two relatively cheap operations to extract the carry.  The other method is to simply 
 shift the most significant bit to the least significant bit thus extracting the carry with a single cheap operation.  This optimization only works on
 twos compliment machines which is a safe assumption to make.
 
-If $a$ has a higher magnitude than $b$ an additional loop (\textit{see lines 64 through 73}) is required to propagate the carry through
+If $a$ has a larger magnitude than $b$ an additional loop (\textit{see lines 63 through 72}) is required to propagate the carry through
 $a$ and copy the result to $c$.  
 
 \subsection{High Level Addition}
@@ -1956,9 +1993,9 @@ established.  This high level addition algorithm will be what other algorithms a
 types.  
 
 Recall from section 5.2 that an mp\_int represents an integer with an unsigned mantissa (\textit{the array of digits}) and a \textbf{sign} 
-flag.  A high level addition is actually performed as a series of eight seperate cases which can be optimized down to three unique cases.
+flag.  A high level addition is actually performed as a series of eight separate cases which can be optimized down to three unique cases.
 
-\newpage\begin{figure}[!here]
+\begin{figure}[!here]
 \begin{center}
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_add}. \\
@@ -1967,11 +2004,11 @@ flag.  A high level addition is actually performed as a series of eight seperate
 \hline \\
 1.  if $a.sign = b.sign$ then do \\
 \hspace{3mm}1.1  $c.sign \leftarrow a.sign$  \\
-\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{hint: use s\_mp\_add})\\
+\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{s\_mp\_add})\\
 2.  else do \\
-\hspace{3mm}2.1  if $\vert a \vert < \vert b \vert$ then do (\textit{hint: use mp\_cmp\_mag})  \\
+\hspace{3mm}2.1  if $\vert a \vert < \vert b \vert$ then do (\textit{mp\_cmp\_mag})  \\
 \hspace{6mm}2.1.1  $c.sign \leftarrow b.sign$ \\
-\hspace{6mm}2.1.2  $c \leftarrow \vert b \vert - \vert a \vert$ (\textit{hint: use s\_mp\_sub}) \\
+\hspace{6mm}2.1.2  $c \leftarrow \vert b \vert - \vert a \vert$ (\textit{s\_mp\_sub}) \\
 \hspace{3mm}2.2  else do \\
 \hspace{6mm}2.2.1  $c.sign \leftarrow a.sign$ \\
 \hspace{6mm}2.2.2  $c \leftarrow \vert a \vert - \vert b \vert$ \\
@@ -1986,9 +2023,9 @@ flag.  A high level addition is actually performed as a series of eight seperate
 \textbf{Algorithm mp\_add.}
 This algorithm performs the signed addition of two mp\_int variables.  There is no reference algorithm to draw upon from either \cite{TAOCPV2} or 
 \cite{HAC} since they both only provide unsigned operations.  The algorithm is fairly straightforward but restricted since subtraction can only 
-produce positive results.  Consider the following chart of possible inputs.
+produce positive results.
 
-\begin{figure}[!here]
+\begin{figure}[here]
 \begin{small}
 \begin{center}
 \begin{tabular}{|c|c|c|c|c|}
@@ -2012,10 +2049,11 @@ produce positive results.  Consider the following chart of possible inputs.
 \end{center}
 \end{small}
 \caption{Addition Guide Chart}
+\label{fig:AddChart}
 \end{figure}
 
-The chart lists all of the eight possible input combinations and is sorted to show that only three specific cases need to be handled.  The 
-return code of the unsigned operations at step 1.2, 2.1.2 and 2.2.2 are forwarded to step 3 to check for errors.  This simpliies the description
+Figure~\ref{fig:AddChart} lists all of the eight possible input combinations and is sorted to show that only three specific cases need to be handled.  The 
+return code of the unsigned operations at step 1.2, 2.1.2 and 2.2.2 are forwarded to step 3 to check for errors.  This simplifies the description
 of the algorithm considerably and best follows how the implementation actually was achieved.
 
 Also note how the \textbf{sign} is set before the unsigned addition or subtraction is performed.  Recall from the descriptions of algorithms
@@ -2075,7 +2113,7 @@ level functions do so.  Returning their return code is sufficient.
 \subsection{High Level Subtraction}
 The high level signed subtraction algorithm is essentially the same as the high level signed addition algorithm.  
 
-\begin{figure}[!here]
+\newpage\begin{figure}[!here]
 \begin{center}
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_sub}. \\
@@ -2084,11 +2122,11 @@ The high level signed subtraction algorithm is essentially the same as the high 
 \hline \\
 1.  if $a.sign \ne b.sign$ then do \\
 \hspace{3mm}1.1  $c.sign \leftarrow a.sign$ \\
-\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{hint: use s\_mp\_add}) \\
+\hspace{3mm}1.2  $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{s\_mp\_add}) \\
 2.  else do \\
-\hspace{3mm}2.1  if $\vert a \vert \ge \vert b \vert$ then do (\textit{hint: use mp\_cmp\_mag}) \\
+\hspace{3mm}2.1  if $\vert a \vert \ge \vert b \vert$ then do (\textit{mp\_cmp\_mag}) \\
 \hspace{6mm}2.1.1  $c.sign \leftarrow a.sign$ \\
-\hspace{6mm}2.1.2  $c \leftarrow \vert a \vert  - \vert b \vert$ (\textit{hint: use s\_mp\_sub}) \\
+\hspace{6mm}2.1.2  $c \leftarrow \vert a \vert  - \vert b \vert$ (\textit{s\_mp\_sub}) \\
 \hspace{3mm}2.2  else do \\
 \hspace{6mm}2.2.1  $c.sign \leftarrow  \left \lbrace \begin{array}{ll}
                               MP\_ZPOS &  \mbox{if }a.sign = MP\_NEG \\
@@ -2108,7 +2146,7 @@ This algorithm performs the signed subtraction of two inputs.  Similar to algori
 \cite{HAC}.  Also this algorithm is restricted by algorithm s\_mp\_sub.  The following chart lists the eight possible inputs and
 the operations required.
 
-\newpage\begin{figure}[!here]
+\begin{figure}[!here]
 \begin{small}
 \begin{center}
 \begin{tabular}{|c|c|c|c|c|}
@@ -2204,7 +2242,7 @@ operation to perform.  A single precision logical shift left is sufficient to mu
 \textbf{Input}.   One mp\_int $a$ \\
 \textbf{Output}.  $b = 2a$. \\
 \hline \\
-1.  If $b.alloc < a.used + 1$ then grow $b$ to hold $a.used + 1$ digits.  (\textit{hint: use mp\_grow}) \\
+1.  If $b.alloc < a.used + 1$ then grow $b$ to hold $a.used + 1$ digits.  (\textit{mp\_grow}) \\
 2.  If the reallocation failed return(\textit{MP\_MEM}). \\
 3.  $oldused \leftarrow b.used$ \\
 4.  $b.used \leftarrow a.used$ \\
@@ -2214,7 +2252,7 @@ operation to perform.  A single precision logical shift left is sufficient to mu
 \hspace{3mm}6.2  $b_n \leftarrow (a_n << 1) + r \mbox{ (mod }\beta\mbox{)}$ \\
 \hspace{3mm}6.3  $r \leftarrow rr$ \\
 7.  If $r \ne 0$ then do \\
-\hspace{3mm}7.1  $b_{a.used} = 1$ \\
+\hspace{3mm}7.1  $b_{n + 1} \leftarrow r$ \\
 \hspace{3mm}7.2  $b.used \leftarrow b.used + 1$ \\
 8.  If $b.used < oldused - 1$ then do \\
 \hspace{3mm}8.1  for $n$ from $b.used$ to $oldused - 1$ do \\
@@ -2242,8 +2280,8 @@ obtain what will be the carry for the next iteration.  Step 6.2 calculates the $
 the previous carry.  Recall from section 5.1 that $a_n << 1$ is equivalent to $a_n \cdot 2$.  An iteration of the addition loop is finished with 
 forwarding the carry to the next iteration.
 
-Step 7 takes care of any final carry by setting the $a.used$'th digit of the result to one and augmenting the \textbf{used} count.  Step 8 clears
-any original leading digits of $b$.
+Step 7 takes care of any final carry by setting the $a.used$'th digit of the result to the carry and augmenting the \textbf{used} count of $b$.  
+Step 8 clears any leading digits of $b$ in case it originally had a larger magnitude than $a$.
 
 \index{bn\_mp\_mul\_2.c}
 \vspace{+3mm}\begin{small}
@@ -2329,7 +2367,7 @@ A division by two can just as easily be accomplished with a logical shift right 
 \textbf{Input}.   One mp\_int $a$ \\
 \textbf{Output}.  $b = a/2$. \\
 \hline \\
-1.  If $b.alloc < a.used$ then grow $b$ to hold $a.used$ digits.  (\textit{hint: use mp\_grow}) \\
+1.  If $b.alloc < a.used$ then grow $b$ to hold $a.used$ digits.  (\textit{mp\_grow}) \\
 2.  If the reallocation failed return(\textit{MP\_MEM}). \\
 3.  $oldused \leftarrow b.used$ \\
 4.  $b.used \leftarrow a.used$ \\
@@ -2342,7 +2380,8 @@ A division by two can just as easily be accomplished with a logical shift right 
 \hspace{3mm}7.1  for $n$ from $b.used$ to $oldused - 1$ do \\
 \hspace{6mm}7.1.1  $b_n \leftarrow 0$ \\
 8.  $b.sign \leftarrow a.sign$ \\
-9.  Return(\textit{MP\_OKAY}).\\
+9.  Clamp excess digits of $b$.  (\textit{mp\_clamp}) \\
+10.  Return(\textit{MP\_OKAY}).\\
 \hline
 \end{tabular}
 \end{center}
@@ -2354,7 +2393,7 @@ A division by two can just as easily be accomplished with a logical shift right 
 This algorithm will divide an mp\_int by two using logical shifts to the right.  Like mp\_mul\_2 it uses a modified low level addition
 core as the basis of the algorithm.  Unlike mp\_mul\_2 the shift operations work from the leading digit to the trailing digit.  The algorithm
 could be written to work from the trailing digit to the leading digit however, it would have to stop one short of $a.used - 1$ digits to prevent
-reading passed the end of the array of digits.
+reading past the end of the array of digits.
 
 Essentially the loop at step 6 is similar to that of mp\_mul\_2 except the logical shifts go in the opposite direction and the carry is at the 
 least significant bit not the most significant bit.  
@@ -2437,10 +2476,10 @@ multiplying by the integer $\beta$.
 \begin{tabular}{l}
 \hline Algorithm \textbf{mp\_lshd}. \\
 \textbf{Input}.   One mp\_int $a$ and an integer $b$ \\
-\textbf{Output}.  $a \leftarrow a \cdot \beta^b$ (Multiply by $x^b$). \\
+\textbf{Output}.  $a \leftarrow a \cdot \beta^b$ (equivalent to multiplication by $x^b$). \\
 \hline \\
 1.  If $b \le 0$ then return(\textit{MP\_OKAY}). \\
-2.  If $a.alloc < a.used + b$ then grow $a$ to at least $a.used + b$ digits.  (\textit{hint: use mp\_grow}). \\
+2.  If $a.alloc < a.used + b$ then grow $a$ to at least $a.used + b$ digits.  (\textit{mp\_grow}). \\
 3.  If the reallocation failed return(\textit{MP\_MEM}). \\
 4.  $a.used \leftarrow a.used + b$ \\
 5.  $i \leftarrow a.used - 1$ \\
@@ -2461,8 +2500,11 @@ multiplying by the integer $\beta$.
 
 \textbf{Algorithm mp\_lshd.}
 This algorithm multiplies an mp\_int by the $b$'th power of $x$.  This is equivalent to multiplying by $\beta^b$.  The algorithm differs 
-from the other algorithms presented so far as it performs the operation in place instead storing the result in a seperate location.  The algorithm
-will return success immediately if $b \le 0$ since the rest of algorithm is only valid when $b > 0$.  
+from the other algorithms presented so far as it performs the operation in place instead storing the result in a separate location.  The
+motivation behind this change is due to the way this function is typically used.  Algorithms such as mp\_add store the result in an optionally
+different third mp\_int because the original inputs are often still required.  Algorithm mp\_lshd (\textit{and similarly algorithm mp\_rshd}) is
+typically used on values where the original value is no longer required.  The algorithm will return success immediately if 
+$b \le 0$ since the rest of algorithm is only valid when $b > 0$.  
 
 First the destination $a$ is grown as required to accomodate the result.  The counters $i$ and $j$ are used to form a \textit{sliding window} over
 the digits of $a$ of length $b$.  The head of the sliding window is at $i$ (\textit{the leading digit}) and the tail at $j$ (\textit{the trailing digit}).  
@@ -2502,29 +2544,29 @@ step 8 sets the lower $b$ digits to zero.
 033     \}
 034   
 035     \{
-036       register mp_digit *tmpa, *tmpaa;
+036       register mp_digit *top, *bottom;
 037   
-038       /* increment the used by the shift amount than copy upwards */
+038       /* increment the used by the shift amount then copy upwards */
 039       a->used += b;
 040   
 041       /* top */
-042       tmpa = a->dp + a->used - 1;
+042       top = a->dp + a->used - 1;
 043   
 044       /* base */
-045       tmpaa = a->dp + a->used - 1 - b;
+045       bottom = a->dp + a->used - 1 - b;
 046   
 047       /* much like mp_rshd this is implemented using a sliding window
 048        * except the window goes the otherway around.  Copying from
 049        * the bottom to the top.  see bn_mp_rshd.c for more info.
 050        */
 051       for (x = a->used - 1; x >= b; x--) \{
-052         *tmpa-- = *tmpaa--;
+052         *top-- = *bottom--;
 053       \}
 054   
 055       /* zero the lower digits */
-056       tmpa = a->dp;
+056       top = a->dp;
 057       for (x = 0; x < b; x++) \{
-058         *tmpa++ = 0;
+058         *top++ = 0;
 059       \}
 060     \}
 061     return MP_OKAY;
@@ -2533,8 +2575,8 @@ step 8 sets the lower $b$ digits to zero.
 \end{small}
 
 The if statement on line 24 ensures that the $b$ variable is greater than zero.  The \textbf{used} count is incremented by $b$ before
-the copy loop begins.  This elminates the need for an additional variable in the for loop.  The variable $tmpa$ on line 42 is an alias
-for the leading digit while $tmpaa$ on line 45 is an alias for the trailing edge.  The aliases form a window of exactly $b$ digits
+the copy loop begins.  This elminates the need for an additional variable in the for loop.  The variable $top$ on line 42 is an alias
+for the leading digit while $bottom$ on line 45 is an alias for the trailing edge.  The aliases form a window of exactly $b$ digits
 over the input.  
 
 \subsection{Division by $x$}
@@ -2551,7 +2593,7 @@ Division by powers of $x$ is easily achieved by shifting the digits right and re
 \hline \\
 1.  If $b \le 0$ then return. \\
 2.  If $a.used \le b$ then do \\
-\hspace{3mm}2.1  Zero $a$.  (\textit{hint: use mp\_zero}). \\
+\hspace{3mm}2.1  Zero $a$.  (\textit{mp\_zero}). \\
 \hspace{3mm}2.2  Return. \\
 3.  $i \leftarrow 0$ \\
 4.  $j \leftarrow b$ \\
@@ -2561,7 +2603,7 @@ Division by powers of $x$ is easily achieved by shifting the digits right and re
 \hspace{3mm}5.3  $j \leftarrow j + 1$ \\
 6.  for $n$ from $a.used - b$ to $a.used - 1$ do \\
 \hspace{3mm}6.1  $a_n \leftarrow 0$ \\
-7.  Clamp excess digits.  (\textit{hint: use mp\_clamp}). \\
+7.  $a.used \leftarrow a.used - b$ \\
 8.  Return. \\
 \hline
 \end{tabular}
@@ -2581,7 +2623,7 @@ After the trivial cases of inputs have been handled the sliding window is setup.
 is $b$ digits wide is used to copy the digits.  Unlike mp\_lshd the window slides in the opposite direction from the trailing to the leading digit.  
 Also the digits are copied from the leading to the trailing edge.
 
-Once the window copy is complete the upper digits must be zeroed.  Finally algorithm mp\_clamp is used to trim excess digits.
+Once the window copy is complete the upper digits must be zeroed and the \textbf{used} count decremented.
 
 \index{bn\_mp\_rshd.c}
 \vspace{+3mm}\begin{small}
@@ -2607,15 +2649,15 @@ Once the window copy is complete the upper digits must be zeroed.  Finally algor
 032     \}
 033   
 034     \{
-035       register mp_digit *tmpa, *tmpaa;
+035       register mp_digit *bottom, *top;
 036   
 037       /* shift the digits down */
 038   
-039       /* base */
-040       tmpa = a->dp;
+039       /* bottom */
+040       bottom = a->dp;
 041   
-042       /* offset into digits */
-043       tmpaa = a->dp + b;
+042       /* top [offset into digits] */
+043       top = a->dp + b;
 044   
 045       /* this is implemented as a sliding window where 
 046        * the window is b-digits long and digits from 
@@ -2628,21 +2670,24 @@ Once the window copy is complete the upper digits must be zeroed.  Finally algor
 053                     \symbol{92}-------------------/      ---->
 054        */
 055       for (x = 0; x < (a->used - b); x++) \{
-056         *tmpa++ = *tmpaa++;
+056         *bottom++ = *top++;
 057       \}
 058   
 059       /* zero the top digits */
 060       for (; x < a->used; x++) \{
-061         *tmpa++ = 0;
+061         *bottom++ = 0;
 062       \}
 063     \}
-064     mp_clamp (a);
-065   \}
+064     
+065     /* remove excess digits */
+066     a->used -= b;
+067   \}
 \end{alltt}
 \end{small}
 
-The only noteworthy element of this routine is the lack of a return type.  This function cannot fail and as such it is more optimal to not
-return anything.
+The only noteworthy element of this routine is the lack of a return type.  
+
+-- Will update later to give it a return type...Tom
 
 \section{Powers of Two}
 
@@ -2660,11 +2705,11 @@ shifts $k$ times to achieve a multiplication by $2^{\pm k}$ a mixture of whole d
 \textbf{Input}.   One mp\_int $a$ and an integer $b$ \\
 \textbf{Output}.  $c \leftarrow a \cdot 2^b$. \\
 \hline \\
-1.  $c \leftarrow a$.  (\textit{hint: use mp\_copy}) \\
+1.  $c \leftarrow a$.  (\textit{mp\_copy}) \\
 2.  If $c.alloc < c.used + \lfloor b / lg(\beta) \rfloor + 2$ then grow $c$ accordingly. \\
 3.  If the reallocation failed return(\textit{MP\_MEM}). \\
 4.  If $b \ge lg(\beta)$ then \\
-\hspace{3mm}4.1  $c \leftarrow c \cdot \beta^{\lfloor b / lg(\beta) \rfloor}$ (\textit{hint: use mp\_lshd}). \\
+\hspace{3mm}4.1  $c \leftarrow c \cdot \beta^{\lfloor b / lg(\beta) \rfloor}$ (\textit{mp\_lshd}). \\
 \hspace{3mm}4.2  If step 4.1 failed return(\textit{MP\_MEM}). \\
 5.  $d \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\
 6.  If $d \ne 0$ then do \\
@@ -2693,7 +2738,8 @@ First the algorithm will multiply $a$ by $x^{\lfloor b / lg(\beta) \rfloor}$ whi
 $\beta$.  For example, if $b = 37$ and $\beta = 2^{28}$ then this step will multiply by $x$ leaving a multiplication by $2^{37 - 28} = 2^{9}$ 
 left.
 
-The logarithm of the residue is calculated on step 5.  If it is non-zero a modified shift loop is used to calculate the remaining product.  
+After the digits have been shifted appropriately at most $lg(\beta) - 1$ shifts are left to perform.  Step 5 calculates the number of remaining shifts 
+required.  If it is non-zero a modified shift loop is used to calculate the remaining product.  
 Essentially the loop is a generic version of algorith mp\_mul2 designed to handle any shift count in the range $1 \le x < lg(\beta)$.  The $mask$
 variable is used to extract the upper $d$ bits to form the carry for the next iteration.  
 
@@ -2787,13 +2833,13 @@ Notes to be revised when code is updated. -- Tom
 \textbf{Output}.  $c \leftarrow \lfloor a / 2^b \rfloor, d \leftarrow a \mbox{ (mod }2^b\mbox{)}$. \\
 \hline \\
 1.  If $b \le 0$ then do \\
-\hspace{3mm}1.1  $c \leftarrow a$ (\textit{hint: use mp\_copy}) \\
-\hspace{3mm}1.2  $d \leftarrow 0$ (\textit{hint: use mp\_zero}) \\
+\hspace{3mm}1.1  $c \leftarrow a$ (\textit{mp\_copy}) \\
+\hspace{3mm}1.2  $d \leftarrow 0$ (\textit{mp\_zero}) \\
 \hspace{3mm}1.3  Return(\textit{MP\_OKAY}). \\
 2.  $c \leftarrow a$ \\
-3.  $d \leftarrow a \mbox{ (mod }2^b\mbox{)}$ (\textit{hint: use mp\_mod\_2d}) \\
+3.  $d \leftarrow a \mbox{ (mod }2^b\mbox{)}$ (\textit{mp\_mod\_2d}) \\
 4.  If $b \ge lg(\beta)$ then do \\
-\hspace{3mm}4.1  $c \leftarrow \lfloor c/\beta^{\lfloor b/lg(\beta) \rfloor} \rfloor$ (\textit{hint: use mp\_rshd}). \\
+\hspace{3mm}4.1  $c \leftarrow \lfloor c/\beta^{\lfloor b/lg(\beta) \rfloor} \rfloor$ (\textit{mp\_rshd}). \\
 5.  $k \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\
 6.  If $k \ne 0$ then do \\
 \hspace{3mm}6.1  $mask \leftarrow 2^k$ \\
@@ -2802,7 +2848,7 @@ Notes to be revised when code is updated. -- Tom
 \hspace{6mm}6.3.1  $rr \leftarrow c_n \mbox{ (mod }mask\mbox{)}$ \\
 \hspace{6mm}6.3.2  $c_n \leftarrow (c_n >> k) + (r << (lg(\beta) - k))$ \\
 \hspace{6mm}6.3.3  $r \leftarrow rr$ \\
-7.  Clamp excess digits of $c$.  (\textit{hint: use mp\_clamp}) \\
+7.  Clamp excess digits of $c$.  (\textit{mp\_clamp}) \\
 8.  Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
@@ -2822,8 +2868,8 @@ by using algorithm mp\_mod\_2d.
 \vspace{-3mm}
 \begin{alltt}
 016   
-017   /* shift right by a certain bit count (store quotient in c, remainder in d) 
-      */
+017   /* shift right by a certain bit count (store quotient in c, optional remaind
+      er in d) */
 018   int
 019   mp_div_2d (mp_int * a, int b, mp_int * c, mp_int * d)
 020   \{
@@ -2891,19 +2937,19 @@ by using algorithm mp\_mod\_2d.
 081       \}
 082     \}
 083     mp_clamp (c);
-084     res = MP_OKAY;
-085     if (d != NULL) \{
-086       mp_exch (&t, d);
-087     \}
-088     mp_clear (&t);
-089     return MP_OKAY;
-090   \}
+084     if (d != NULL) \{
+085       mp_exch (&t, d);
+086     \}
+087     mp_clear (&t);
+088     return MP_OKAY;
+089   \}
 \end{alltt}
 \end{small}
 
 The implementation of algorithm mp\_div\_2d is slightly different than the algorithm specifies.  The remainder $d$ may be optionally 
 ignored by passing \textbf{NULL} as the pointer to the mp\_int variable.    The temporary mp\_int variable $t$ is used to hold the 
-result of the remainder operation until the end.  This allows $d = a$ to be true without overwriting the input before they are no longer required.  
+result of the remainder operation until the end.  This allows $d$ and $a$ to represent the same mp\_int without modifying $a$ before
+the quotient is obtained.
 
 The remainder of the source code is essentially the same as the source code for mp\_mul\_2d.  (-- Fix this paragraph up later, Tom).
 
@@ -2921,10 +2967,10 @@ algorithm benefits from the fact that in twos complement arithmetic $a \mbox{ (m
 \textbf{Output}.  $c \leftarrow a \mbox{ (mod }2^b\mbox{)}$. \\
 \hline \\
 1.  If $b \le 0$ then do \\
-\hspace{3mm}1.1  $c \leftarrow 0$ (\textit{hint: use mp\_zero}) \\
+\hspace{3mm}1.1  $c \leftarrow 0$ (\textit{mp\_zero}) \\
 \hspace{3mm}1.2  Return(\textit{MP\_OKAY}). \\
 2.  If $b > a.used \cdot lg(\beta)$ then do \\
-\hspace{3mm}2.1  $c \leftarrow a$ (\textit{hint: use mp\_copy}) \\
+\hspace{3mm}2.1  $c \leftarrow a$ (\textit{mp\_copy}) \\
 \hspace{3mm}2.2  Return the result of step 2.1. \\
 3.  $c \leftarrow a$ \\
 4.  If step 3 failed return(\textit{MP\_MEM}). \\
@@ -2932,7 +2978,8 @@ algorithm benefits from the fact that in twos complement arithmetic $a \mbox{ (m
 \hspace{3mm}5.1  $c_n \leftarrow 0$ \\
 6.  $k \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\
 7.  $c_{\lfloor b / lg(\beta) \rfloor} \leftarrow c_{\lfloor b / lg(\beta) \rfloor} \mbox{ (mod }2^{k}\mbox{)}$. \\
-8.  Return(\textit{MP\_OKAY}). \\
+8.  Clamp excess digits of $c$.  (\textit{mp\_clamp}) \\
+9.  Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
 \end{center}
@@ -3013,10 +3060,6 @@ $\left [ 5 \right ] $ & Improve the previous algorithm to have a working time of
                       & $O \left (2^{(k-1)}n + \left ({2n^2 \over k} \right ) \right )$ for an appropriate choice of $k$.  Again ignore \\
                       & the cost of addition. \\
                       & \\
-$\left [ 1 \right ] $ & There exists an improvement on the previous algorithm to \\
-                      & slightly reduce the number of additions required.  Modify the \\
-                      & previous algorithm to include this improvement. \\
-                      & \\
 $\left [ 2 \right ] $ & Devise a chart to find optimal values of $k$ for the previous problem \\
                       & for $n = 64 \ldots 1024$ in steps of $64$. \\
                       & \\
@@ -3094,8 +3137,10 @@ Compute the product. \\
 \caption{Algorithm s\_mp\_mul\_digs}
 \end{figure}
 
+
+
 \textbf{Algorithm s\_mp\_mul\_digs.}
-This algorithm computes the unsigned product of two inputs $a$ and $c$ limited to an output precision of $digs$ digits.  While it may seem
+This algorithm computes the unsigned product of two inputs $a$ and $b$ limited to an output precision of $digs$ digits.  While it may seem
 a bit awkward to modify the function from its simple $O(n^2)$ description the usefulness of partial multipliers will arise in a future 
 algorithm.  The algorithm is loosely based on algorithm 14.12 from \cite[pp. 595]{HAC} and is similar to Algorithm M \cite[pp. 268]{TAOCPV2}.  The
 algorithm differs from those cited references because it can produce a variable output precision regardless of the precision of the inputs.
@@ -3234,7 +3279,8 @@ x86 processor can multiply two 32-bit values and produce a 64-bit result.
 One of the huge drawbacks of the ``baseline'' algorithms is that at the $O(n^2)$ level the carry must be computed and propagated upwards.  This
 makes the nested loop very sequential and hard to unroll and implement in parallel.  The ``Comba'' method is named after little known 
 (\textit{in cryptographic venues}) Paul G. Comba where in \cite{COMBA} a method of implementing fast multipliers that do not require nested 
-carry fixup operations was presented.
+carry fixup operations was presented.  As an interesting aside it seems that Paul Barrett  describes a similar technique in
+his 1986 paper \cite{BARRETT} which was written five years before \cite{COMBA}.  
 
 At the heart of algorithm is once again the long-hand algorithm for multiplication.  Except in this case a slight twist is placed on how
 the columns of the result are produced.  In the standard long-hand algorithm rows of products are produced then added together to form the 
@@ -3322,7 +3368,7 @@ which is much larger than the typical $2^{100}$ to $2^{4000}$ range most public 
 \textbf{Output}.  $c \leftarrow \vert a \vert \cdot \vert b \vert \mbox{ (mod }\beta^{digs}\mbox{)}$. \\
 \hline \\
 Place an array of \textbf{MP\_WARRAY} double precision digits named $\hat W$ on the stack. \\
-1.  If $c.alloc < digs$ then grow $c$ to $digs$ digits. (\textit{hint: use mp\_grow}) \\
+1.  If $c.alloc < digs$ then grow $c$ to $digs$ digits. (\textit{mp\_grow}) \\
 2.  If step 1 failed return(\textit{MP\_MEM}).\\
 \\
 Zero the temporary array $\hat W$. \\
@@ -3351,7 +3397,7 @@ Zero excess digits. \\
 10.  If $digs < oldused$ then do \\
 \hspace{3mm}10.1  for $n$ from $digs$ to $oldused - 1$ do \\
 \hspace{6mm}10.1.1  $c_n \leftarrow 0$ \\
-11.  Clamp excessive digits of $c$.  (\textit{hint: use mp\_clamp}) \\
+11.  Clamp excessive digits of $c$.  (\textit{mp\_clamp}) \\
 12.  Return(\textit{MP\_OKAY}). \\
 \hline
 \end{tabular}
@@ -3512,97 +3558,116 @@ baseline method there are dependency stalls as the algorithm must wait for the m
 digit.  As a result fewer of the often multiple execution units\footnote{The AMD Athlon has three execution units and the Intel P4 has four.} can
 be simultaneously used.  
 
-\subsection{Multiplication at New Bounds by Karatsuba Method}
-So far two methods of multiplication have been presented.  Both of the algorithms require asymptotically $O(n^2)$ time to multiply two $n$-digit 
-numbers together.  While the Comba method is much faster than the baseline algorithm it still requires far too much time to multiply 
-large inputs together.  In fact it was not until \cite{KARA} in 1962 that a faster algorithm had been proposed at all.
-
-The idea behind Karatsubas method is that an input can be represented in polynomial basis as two halves then multiplied.  For example, if 
-$f(x) = ax + b$ and $g(x) = cx + b$ then the product of the two polynomials $h(x) = f(x)g(x)$ will allow $h(\beta) = (f(\beta))(g(\beta))$.  
-
-So how does this help?  First expand the product $h(x)$.
+\subsection{Polynomial Basis Multiplication}
+To break the $O(n^2)$ barrier in multiplication requires a completely different look at integer multiplication.  In the following algorithms
+the use of polynomial basis representation for two integers $a$ and $b$ as $f(x) = \sum_{i=0}^{n} a_i x^i$ and  
+$g(x) = \sum_{i=0}^{n} b_i x^i$. respectively, is required.  In this system both $f(x)$ and $g(x)$ have $n + 1$ terms and are of the $n$'th degree.
+ 
+The product $a \cdot b \equiv f(x) \cdot g(x)$ is the polynomial $W(x) = \sum_{i=0}^{2n} w_i x^i$.  The coefficients $w_i$ will
+directly yield the desired product when $\beta$ is substituted for $x$.  The direct solution to solve for the $2n + 1$ coefficients
+requires $O(n^2)$ time and is would be in practice slower than the Comba technique.
+
+However, numerical analysis theory will indicate that only $2n + 1$ points in $W(x)$ are required to provide $2n + 1$ knowns for the $2n + 1$ unknowns.  
+This means by finding $\zeta_y = W(y)$ for $2n + 1$ small values of $y$ the coefficients of $W(x)$ can be found with trivial Gaussian elimination.  
+Since the polynomial $W(x)$ is unknown the equivalent $\zeta_y = f(y) \cdot g(y)$ is used in its place.  
+
+The benefit of this technique stems from the fact that $f(y)$ and $g(y)$ are much smaller than either $a$ or $b$ respectively.  In fact if 
+both polynomials have $n + 1$ terms then the multiplicands will be $n$  times smaller than the inputs.  Even if $2n + 1$ multiplications are required
+since they are of smaller values the algorithm is still faster.
+
+When picking points to gather relations there are always three obvious points to choose, $y = 0, 1$ and $ \infty$.  The $\zeta_0$ term
+is simply the product $W(0) = w_0 = a_0 \cdot b_0$.  The $\zeta_1$ term is the product 
+$W(1) = \left (\sum_{i = 0}^{n} a_i \right ) \left (\sum_{i = 0}^{n} b_i \right )$.  The third point $\zeta_{\infty}$ is less obvious but rather
+simple to explain.  The $2n + 1$'th coefficient of $W(x)$ is numerically equivalent to the most significant column in an integer multiplication.  
+The point at $\infty$ is used symbolically to represent the most significant column, that is $W(\infty) = w_{2n + 1} = a_nb_n$.  Note that the 
+points at $y = 0$ and $\infty$ yield the coefficients $w_0$ and $w_{2n + 1}$ directly.
+
+If more points are required they should be of small input values which are powers of two such as 
+$2^q$ and the related \textit{mirror points} $\left (2^q \right )^{2n}  \cdot \zeta_{2^{-q}}$ for small values of $q$.  Using such 
+points will allow the values of $f(y)$ and $g(y)$ to be independently calculated using only left shifts.
+
+As a general rule of the algorithm when the inputs are split into $n$ parts each there are $2n - 1$ multiplications.  Each multiplication is of 
+multiplicands that have $n$ times fewer digits than the inputs.  The asymptotic running time of this algorithm is 
+$O \left ( k^{lg_n(2n - 1)} \right )$ for $k$ digit inputs (\textit{assuming they have the same number of digits}).  The following table 
+summarizes the exponents for various values of $n$.
 
+\newpage\begin{figure}
 \begin{center}
-\begin{tabular}{rcl}
-$h(x)$ & $=$ & $f(x)g(x)$ \\
-       & $=$ & $(ax + b)(cx + d)$ \\
-       & $=$ & $acx^2 + adx + bcx + bd$ \\
+\begin{tabular}{|c|c|c|}
+\hline \textbf{Split into $n$ Parts} & \textbf{Exponent}  & \textbf{Notes}\\
+\hline $2$ & $1.584962501$ & This is Karatsuba Multiplication. \\
+\hline $3$ & $1.464973520$ & This is Toom-Cook Multiplication. \\
+\hline $4$ & $1.403677461$ &\\
+\hline $5$ & $1.365212389$ &\\
+\hline $10$ & $1.278753601$ &\\
+\hline $100$ & $1.149426538$ &\\
+\hline $1000$ & $1.100270931$ &\\
+\hline $10000$ & $1.075252070$ &\\
+\hline
 \end{tabular}
 \end{center}
+\caption{Asymptotic Running Time of Polynomial Basis Multiplication}
+\end{figure}
 
-The next equation is a bit of genius on the part of Karatsuba.  He proved that the previous equation is equivalent to 
-
-\begin{equation}
-h(x) = acx^2 + ((a - c)(b - d) + bd + ac)x + bd
-\end{equation}
+At first it may seem like a good idea to choose $n = 1000$ since afterall the exponent is approximately $1.1$.  However, the overhead
+of solving for the 2001 terms of $W(x)$ will certainly consume any savings the algorithm could offer for all but exceedingly large
+numbers.  
 
-Essentially the proof lies in some fairly light algebraic number theory (\textit{see \cite{KARAP} for details}) that is not important for
-the discussion.  At first glance it appears that the Karatsuba method is actually harder than the straight $O(n^2)$ approach.  
-However, further investigation will prove otherwise.  
+\subsubsection{Cutoff Point}
+The polynomial basis multiplication algorithms all require fewer single precision multiplications than a straight Comba approach.  However, 
+the algorithms incur an overhead (\textit{at the $O(n)$ work level}) since they require a system of equations to be solved.  This makes them costly to 
+use with small inputs.  
 
-The first important observation is that both $f(x)$ and $g(x)$ are the polynomial basis representation of two-digit numbers.  This means that 
-$\left < a, b, c, d \right >$ are single digit values.  Using either the baseline or straight polynomial multiplication the old method requires
-$O \left (4(n/2)^2 \right ) = O(n^2)$ single precision multiplications.  Looking closer at Karatsubas equation there are only three unique multiplications 
-required which are $ac$, $bd$ and $(a - c)(b - d)$.  As a result only $O \left (3 \cdot (n/2)^2 \right ) = O \left ( {3 \over 4}n^2 \right )$ 
-multiplications are required.  
+Let $m$ represent the number of digits in the multiplicands (\textit{assume both multiplicands have the same number of digits}).  There exists a 
+point $y$ such that when $m < y$ the polynomial basis algorithms are more costly than Comba, when $m = y$ they are roughly the same cost and 
+when $m > y$ the Comba methods are slower than the polynomial basis algorithms.  
 
-So far the algorithm has been discussed from the point of view of ``two-digit'' numbers.  However, there is no reason why two digits implies a range of 
-$\beta^2$.  It could just as easily represent a range of $\left (\beta^k \right)^2$ as well.  For example, the polynomial 
-$f(x) = a_3x^3 + a_2x^2 + a_1x + a_0$ could also be written as $f'(x) = a'_1x + a'_0$ where $f(\beta) = f'(\beta^2)$.  Fortunately representing an
-integer which is already in an array of radix-$\beta$ digits in polynomial basis in terms of a power of $\beta$ is very simple.  
+The exact location of $y$ depends on several key architectural elements of the computer platform in question.
 
-\subsubsection{Recursion}
-The Karatsuba multiplication algorithm can be applied to practically any size of input.  Therefore, it is possible that the Karatsuba method itself
-be used for the three multiplications required.  For example, when multiplying two four-digit numbers there will be three multiplications of two-digit
-numbers.  In this case the smaller multiplication requires $p(n) = {3 \over 4}n^2$ time to complete while the larger multiplication requires
-$q(n) = 3 \cdot p(n/2)$ multiplications.  
+\begin{enumerate}
+\item  The ratio of clock cycles for single precision multiplication versus other simpler operations such as addition, shifting, etc.  For example
+on the AMD Athlon the ratio is roughly $17 : 1$ while on the Intel P4 it is $29 : 1$.  The higher the ratio in favour of multiplication the lower
+the cutoff point $y$ will be.  
 
-By expanding $q(n)$ the following equation is achieved. 
+\item  The complexity of the linear system of equations (\textit{for the coefficients of $W(x)$}) is.  Generally speaking as the number of splits
+grows the complexity grows substantially.  Ideally solving the system will only involve addition, subtraction and shifting of integers.  This
+directly reflects on the ratio previous mentioned.
 
-\begin{center}
-\begin{tabular}{rcl}
-$q(n)$ & $=$ & $3 \cdot p(n/2)$ \\
-       & $=$ & $3 \cdot (3 \cdot ((n/2)/2)^2)$ \\
-       & $=$ & $9 \cdot (n/4)^2$ \\
-       & $=$ & ${9 \over 16}n^2$ \\
-\end{tabular}
-\end{center}
+\item  To a lesser extent memory bandwidth and function call overheads.  Provided the values are in the processor cache this is less of an
+influence over the cutoff point.
 
-The generic expression for the multiplicand is simply $\left ( {3 \over 4} \right )^k$ for $k \ge 1$ recurisions.  The maximal number of recursions
-is approximately $lg(n)$.  Putting this all in terms of a base $n$ logarithm the asymptotic running time can be deduced.
+\end{enumerate}
 
-\begin{center}
-\begin{tabular}{rcl}
-$lg_n \left ( \left ( {3 \over 4} \right )^{lg_2 n} \cdot n^2 \right )$ & $=$ & $lg_2 n \cdot lg_n \left ( { 3 \over 4 } \right ) + 2$ \\
-                                                                        & $=$ & $\left ( {log N \over log 2} \right ) \cdot \left ( {log \left ( {3 \over 4} \right ) \over log N } \right ) + 2$ \\
-                                                                        & $=$ & ${ log 3 - log 2^2 + 2 \cdot log 2} \over log 2$ \\
-                                                                        & $=$ & $log 3 \over log 2$ \\
-\end{tabular}
-\end{center}
+A clean cutoff point separation occurs when a point $y$ is found such that all of the cutoff point conditions are met.  For example, if the point
+is too low then there will be values of $m$ such that $m > y$ and the Comba method is still faster.  Finding the cutoff points is fairly simple when
+a high resolution timer is available.  
 
-Which leads to a running time of $O \left ( n^{lg(3)} \right )$ which is approximately $O(n^{1.584})$.  This can lead to 
-impressive savings with fairly moderate sized numbers.  For example, when multiplying two 128-digit numbers the Karatsuba 
-method saves $14,197$ (\textit{or $86\%$ of the total}) single precision multiplications.  
+\subsection{Karatsuba Multiplication}
+Karatsuba multiplication \cite{KARA} when originally proposed in 1962 was among the first set of algorithms to break the $O(n^2)$ barrier for
+general purpose multiplication.  Given two polynomial basis representations $f(x) = ax + b$ and $g(x) = cx + d$ Karatsuba proved with 
+light number theory \cite{KARAP} that the following polynomial is equivalent to multiplication of the two integers the polynomials represent.
 
-The immediate question becomes why not simply use Karatsuba multiplication all the time and forget about the baseline and Comba algorithms? 
+\begin{equation}
+f(x) \cdot g(x) = acx^2 + ((a - b)(c - d) + ac + bd)x + bd
+\end{equation}
 
-\subsubsection{Overhead}
-While the Karatsuba method saves on the number of single precision multiplications required this savings is not entirely free.  The product
-of three half size products must be stored somewhere as well as four additions and two subtractions performed.  These operations incur sufficient
-overhead that often for fairly trivial sized inputs the Karatsuba method is slower.
+Using the observation that $ac$ and $bd$ could be re-used only three half sized multiplications would be required to produce the product.  Applying
+this recursively the work factor becomes $O(n^{lg(3)})$ which is substantially better than the work factor $O(n^2)$ of the Comba technique.  It turns 
+out what Karatsuba did not know or at least did not publish was that this is simply polynomial basis multiplication with the points 
+$\zeta_0$, $\zeta_{\infty}$ and $-\zeta_{-1}$.  Consider the resultant system of equations.
 
-\index{cutoff point}
-The \textit{cutoff point} for Karatsuba multiplication is the point at which the Karatsuba multiplication and baseline (\textit{or Comba}) meet.  
-For the purposes of this discussion call this value $x$.  For any input with $n$ digits such that $n < x$ Karatsuba multiplication will be slower 
-and for $n > x$ it will be faster.  Often the break between the two algorithms is not so clean cut in reality.  The cleaner the cut the more 
-efficient multiplication will be which is why tuning the multiplication is a very important process.  For example, a properly tuned Karatsuba 
-multiplication algorithm can multiply two $4,096$ bit numbers up to five times faster on an Athlon processor compared to the standard baseline
-algorithm.  
+\begin{center}
+\begin{tabular}{rcrcrcrc}
+$\zeta_{0}$ &      $=$ &  &  &  & & $w_0$ \\
+$-\zeta_{-1}$ &    $=$ & $-w_2$ & $+$ & $w_1$ & $-$ & $w_0$ \\
+$\zeta_{\infty}$ & $=$ & $w_2$ &  & &  & \\
+\end{tabular}
+\end{center}
 
-The exact placement of the value of $x$ depends on several key factors.   The cost of allocating storage for the temporary variables, the cost of 
-performing the additions and most importantly the cost of performing a single precision multiplication.  With a processor where single precision 
-multiplication is fast\footnote{The AMD Athlon for instance has a six cycle multiplier compared to the Intel P4 which has a 15 cycle multiplier.} the 
-cutoff point will move upwards.  Similarly with a slower processor the cutoff point will move downwards.  
+By adding the first and last equation to the equation in the middle the term $w_1$ can be isolated and all three coefficients solved for.  The simplicity
+of this system of equations has made Karatsuba fairly popular.  In fact the cutoff point is often fairly low\footnote{With LibTomMath 0.18 it is 70 and 109 for the Intel P4 and AMD Athlon respectively.}
+making it an ideal algorithm to speed up certain public key cryptosystems such as RSA and Diffie-Hellman.  It is worth noting that the point 
+$\zeta_1$ could be substituted for $-\zeta_{-1}$.  In this case the first and third row are subtracted instead of added to the second row.  
 
 \newpage\begin{figure}[!here]
 \begin{small}
@@ -3612,20 +3677,20 @@ cutoff point will move upwards.  Similarly with a slower processor the cutoff po
 \textbf{Input}.   mp\_int $a$ and mp\_int $b$ \\
 \textbf{Output}.  $c \leftarrow \vert a \vert \cdot \vert b \vert$ \\
 \hline \\
-1.  $B \leftarrow \mbox{min}(a.used, b.used)/2$ \\
-2.  Init the following mp\_int variables: $x0$, $x1$, $y0$, $y1$, $t1$, $x0y0$, $x1y1$.\\
-3.  If step 2 failed then return(\textit{MP\_MEM}). \\
+1.  Init the following mp\_int variables: $x0$, $x1$, $y0$, $y1$, $t1$, $x0y0$, $x1y1$.\\
+2.  If step 2 failed then return(\textit{MP\_MEM}). \\
 \\
 Split the input.  e.g. $a = x1 \cdot \beta^B + x0$ \\
-4.  $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{hint: use mp\_mod\_2d}) \\
+3.  $B \leftarrow \mbox{min}(a.used, b.used)/2$ \\
+4.  $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{mp\_mod\_2d}) \\
 5.  $y0 \leftarrow b \mbox{ (mod }\beta^B\mbox{)}$ \\
-6.  $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{hint: use mp\_rshd}) \\
+6.  $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{mp\_rshd}) \\
 7.  $y1 \leftarrow \lfloor b / \beta^B \rfloor$ \\
 \\
 Calculate the three products. \\
-8.  $x0y0 \leftarrow x0 \cdot y0$ (\textit{hint: use mp\_mul}) \\
+8.  $x0y0 \leftarrow x0 \cdot y0$ (\textit{mp\_mul}) \\
 9.  $x1y1 \leftarrow x1 \cdot y1$ \\
-10.  $t1 \leftarrow x1 - x0$ (\textit{hint: use mp\_sub}) \\
+10.  $t1 \leftarrow x1 - x0$ (\textit{mp\_sub}) \\
 11.  $x0 \leftarrow y1 - y0$ \\
 12.  $t1 \leftarrow t1 \cdot x0$ \\
 \\
@@ -3634,7 +3699,7 @@ Calculate the middle term. \\
 14.  $t1 \leftarrow x0 - t1$ \\
 \\
 Calculate the final product. \\
-15.  $t1 \leftarrow t1 \cdot \beta^B$ (\textit{hint: use mp\_lshd}) \\
+15.  $t1 \leftarrow t1 \cdot \beta^B$ (\textit{mp\_lshd}) \\
 16.  $x1y1 \leftarrow x1y1 \cdot \beta^{2B}$ \\
 17.  $t1 \leftarrow x0y0 + t1$ \\
 18.  $c \leftarrow t1 + x1y1$ \\
@@ -3648,103 +3713,3302 @@ Calculate the final product. \\
 \end{figure}
 
 \textbf{Algorithm mp\_karatsuba\_mul.}
+This algorithm computes the unsigned product of two inputs using the Karatsuba method.  It is loosely based on the description
+from \cite[pp. 294-295]{TAOCPV2}.  
 
+\index{radix point}
+In order to split the two inputs into their respective halves a suitable \textit{radix point} must be chosen.  The radix point chosen must
+be used for both of the inputs meaning that it must smaller than the smallest input.  Step 3 chooses the radix point $B$ as half of the 
+smallest input \textbf{used} count.  After the radix point is chosen the inputs are split into lower and upper halves.  Step 4 and 5 
+compute the lower halves.  Step 6 and 7 computer the upper halves.  
 
-\section{Squaring}
-\subsection{The Baseline Squaring Algorithm}
-\subsection{Faster Squaring by the ``Comba'' Method}
-\subsection{Karatsuba Squaring}
-\section{Tuning Algorithms}
-\subsection{How to Tune Karatsuba Algorithms}
+After the halves have been computed the three intermediate half-size products must be computed.  Step 8 and 9 compute the trivial products
+$x0 \cdot y0$ and $x1 \cdot y1$.  The mp\_int $x0$ is used as a temporary variable after $x1 - x0$ has been computed.  By using $x0$ instead
+of an additional temporary variable the algorithm can avoid an addition memory allocation operation.
 
-\chapter{Modular Reductions}
-\section{Basics of Modular Reduction}
-\section{The Barrett Reduction}
-\section{The Montgomery Reduction}
-\subsection{Faster ``Comba'' Montgomery Reduction}
-\subsection{Example Montgomery Algorithms}
-\section{The Diminished Radix Algorithm}
-\section{Algorithm Comparison}
+The remaining steps 13 through 18 compute the Karatsuba polynomial through a variety of digit shifting and addition operations.
 
-\chapter{Exponentiation}
-\section{Single Digit Exponentiation}
-\section{Modular Exponentiation}
-\subsection{General Case}
-\subsection{Odd or Diminished Radix Moduli}
-\section{Quick Power of Two}
+\index{bn\_mp\_karatsuba\_mul.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_karatsuba\_mul.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* c = |a| * |b| using Karatsuba Multiplication using 
+018    * three half size multiplications
+019    *
+020    * Let B represent the radix [e.g. 2**DIGIT_BIT] and 
+021    * let n represent half of the number of digits in 
+022    * the min(a,b)
+023    *
+024    * a = a1 * B**n + a0
+025    * b = b1 * B**n + b0
+026    *
+027    * Then, a * b => 
+028      a1b1 * B**2n + ((a1 - a0)(b1 - b0) + a0b0 + a1b1) * B + a0b0
+029    *
+030    * Note that a1b1 and a0b0 are used twice and only need to be 
+031    * computed once.  So in total three half size (half # of 
+032    * digit) multiplications are performed, a0b0, a1b1 and 
+033    * (a1-b1)(a0-b0)
+034    *
+035    * Note that a multiplication of half the digits requires
+036    * 1/4th the number of single precision multiplications so in 
+037    * total after one call 25% of the single precision multiplications 
+038    * are saved.  Note also that the call to mp_mul can end up back 
+039    * in this function if the a0, a1, b0, or b1 are above the threshold.  
+040    * This is known as divide-and-conquer and leads to the famous 
+041    * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than 
+042    * the standard O(N**2) that the baseline/comba methods use.  
+043    * Generally though the overhead of this method doesn't pay off 
+044    * until a certain size (N ~ 80) is reached.
+045    */
+046   int
+047   mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c)
+048   \{
+049     mp_int  x0, x1, y0, y1, t1, x0y0, x1y1;
+050     int     B, err;
+051   
+052     err = MP_MEM;
+053   
+054     /* min # of digits */
+055     B = MIN (a->used, b->used);
+056   
+057     /* now divide in two */
+058     B = B / 2;
+059   
+060     /* init copy all the temps */
+061     if (mp_init_size (&x0, B) != MP_OKAY)
+062       goto ERR;
+063     if (mp_init_size (&x1, a->used - B) != MP_OKAY)
+064       goto X0;
+065     if (mp_init_size (&y0, B) != MP_OKAY)
+066       goto X1;
+067     if (mp_init_size (&y1, b->used - B) != MP_OKAY)
+068       goto Y0;
+069   
+070     /* init temps */
+071     if (mp_init_size (&t1, B * 2) != MP_OKAY)
+072       goto Y1;
+073     if (mp_init_size (&x0y0, B * 2) != MP_OKAY)
+074       goto T1;
+075     if (mp_init_size (&x1y1, B * 2) != MP_OKAY)
+076       goto X0Y0;
+077   
+078     /* now shift the digits */
+079     x0.sign = x1.sign = a->sign;
+080     y0.sign = y1.sign = b->sign;
+081   
+082     x0.used = y0.used = B;
+083     x1.used = a->used - B;
+084     y1.used = b->used - B;
+085   
+086     \{
+087       register int x;
+088       register mp_digit *tmpa, *tmpb, *tmpx, *tmpy;
+089   
+090       /* we copy the digits directly instead of using higher level functions
+091        * since we also need to shift the digits
+092        */
+093       tmpa = a->dp;
+094       tmpb = b->dp;
+095   
+096       tmpx = x0.dp;
+097       tmpy = y0.dp;
+098       for (x = 0; x < B; x++) \{
+099         *tmpx++ = *tmpa++;
+100         *tmpy++ = *tmpb++;
+101       \}
+102   
+103       tmpx = x1.dp;
+104       for (x = B; x < a->used; x++) \{
+105         *tmpx++ = *tmpa++;
+106       \}
+107   
+108       tmpy = y1.dp;
+109       for (x = B; x < b->used; x++) \{
+110         *tmpy++ = *tmpb++;
+111       \}
+112     \}
+113   
+114     /* only need to clamp the lower words since by definition the 
+115      * upper words x1/y1 must have a known number of digits
+116      */
+117     mp_clamp (&x0);
+118     mp_clamp (&y0);
+119   
+120     /* now calc the products x0y0 and x1y1 */
+121     /* after this x0 is no longer required, free temp [x0==t2]! */
+122     if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY)  
+123       goto X1Y1;          /* x0y0 = x0*y0 */
+124     if (mp_mul (&x1, &y1, &x1y1) != MP_OKAY)
+125       goto X1Y1;          /* x1y1 = x1*y1 */
+126   
+127     /* now calc x1-x0 and y1-y0 */
+128     if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
+129       goto X1Y1;          /* t1 = x1 - x0 */
+130     if (mp_sub (&y1, &y0, &x0) != MP_OKAY)
+131       goto X1Y1;          /* t2 = y1 - y0 */
+132     if (mp_mul (&t1, &x0, &t1) != MP_OKAY)
+133       goto X1Y1;          /* t1 = (x1 - x0) * (y1 - y0) */
+134   
+135     /* add x0y0 */
+136     if (mp_add (&x0y0, &x1y1, &x0) != MP_OKAY)
+137       goto X1Y1;          /* t2 = x0y0 + x1y1 */
+138     if (mp_sub (&x0, &t1, &t1) != MP_OKAY)
+139       goto X1Y1;          /* t1 = x0y0 + x1y1 - (x1-x0)*(y1-y0) */
+140   
+141     /* shift by B */
+142     if (mp_lshd (&t1, B) != MP_OKAY)
+143       goto X1Y1;          /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */
+144     if (mp_lshd (&x1y1, B * 2) != MP_OKAY)
+145       goto X1Y1;          /* x1y1 = x1y1 << 2*B */
+146   
+147     if (mp_add (&x0y0, &t1, &t1) != MP_OKAY)
+148       goto X1Y1;          /* t1 = x0y0 + t1 */
+149     if (mp_add (&t1, &x1y1, c) != MP_OKAY)
+150       goto X1Y1;          /* t1 = x0y0 + t1 + x1y1 */
+151   
+152     err = MP_OKAY;
+153   
+154   X1Y1:mp_clear (&x1y1);
+155   X0Y0:mp_clear (&x0y0);
+156   T1:mp_clear (&t1);
+157   Y1:mp_clear (&y1);
+158   Y0:mp_clear (&y0);
+159   X1:mp_clear (&x1);
+160   X0:mp_clear (&x0);
+161   ERR:
+162     return err;
+163   \}
+\end{alltt}
+\end{small}
 
-\chapter{Higher Level Algorithms}
-\section{Integer Division with Remainder}
-\section{Single Digit Helpers}
-\subsection{Single Digit Addition}
-\subsection{Single Digit Subtraction}
-\subsection{Single Digit Multiplication}
-\subsection{Single Digit Division}
-\subsection{Single Digit Modulo}
-\subsection{Single Digit Root Extraction}
-\section{Random Number Generation}
-\section{Formatted Output}
-\subsection{Getting The Output Size}
-\subsection{Generating Radix-n Output}
-\subsection{Reading Radix-n Input}
-\section{Unformatted Output}
-\subsection{Getting The Output Size}
-\subsection{Generating Output}
-\subsection{Reading Input}
+The new coding element in this routine that has not been seen in the previous routines yet is the usage of the goto statements.  The normal
+wisdom is that goto statements should be avoided.  This is generally true however, when every single function call can fail it makes sense
+to handle error recovery with a single piece of code.  Lines 61 to 75 handle initializing all of the temporary variables 
+required.  Note how each of the if statements goes to a different label in case of failure.  This allows the routine to correctly free only
+the temporaries that have been successfully allocated so far.
 
-\chapter{Number Theoretic Algorithms}
-\section{Greatest Common Divisor}
-\section{Least Common Multiple}
-\section{Jacobi Symbol Computation}
-\section{Modular Inverse}
-\subsection{General Case}
-\subsection{Odd Moduli}
-\section{Primality Tests}
-\subsection{Trial Division}
-\subsection{The Fermat Test}
-\subsection{The Miller-Rabin Test}
-\subsection{Primality Test in a Bottle}
-\subsection{The Next Prime}
-\section{Root Extraction}
+The temporary variables are all initialized using the mp\_init\_size routine since they are expected to be large.  This saves the 
+additional reallocation that would have been necessary.  Also $x0$, $x1$, $y0$ and $y1$ have to be able to hold at least their respective
+number of digits for the next section of code.
 
-\backmatter
-\appendix
-\begin{thebibliography}{ABCDEF}
-\bibitem[1]{TAOCPV2}
-Donald Knuth, \textit{The Art of Computer Programming}, Third Edition, Volume Two, Seminumerical Algorithms, Addison-Wesley, 1998
+The first algebraic portion of the algorithm is to split the two inputs into their halves.  However, instead of using mp\_mod\_2d and mp\_rshd
+to extract the halves the code has been inlined.  To initialize the halves the \textbf{used} and \textbf{sign} members are copied first.  The first
+for loop on line 98 copies the lower halves.  Since they are both the same magnitude it is simpler to calculate both lower halves in a single
+loop.  The for loop on lines 104 and 109 calculate the upper halves $x1$ and $y1$ respectively.
 
-\bibitem[2]{HAC}
-A. Menezes, P. van Oorschot, S. Vanstone, \textit{Handbook of Applied Cryptography}, CRC Press, 1996
+By inlining the calculation of the halves the Karatsuba multiplier has a slightly lower overhead.  As a result it can be used for smaller 
+inputs.
 
-\bibitem[3]{ROSE}
-Michael Rosing, \textit{Implementing Elliptic Curve Cryptography}, Manning Publications, 1999
+When line 152 is reached the algorithm has completed succesfully.  The ``error status'' variable $err$ is set to \textbf{MP\_OKAY} so that
+the same code that handles errors can be used to clear the temporary variables and return.  
 
-\bibitem[4]{COMBA}
-Paul G. Comba, \textit{Exponentiation Cryptosystems on the IBM PC}. IBM Systems Journal 29(4): 526-538 (1990)
+\subsection{Toom-Cook $3$-Way Multiplication}
+Toom-Cook $3$-Way multiplication \cite{TOOM} is essentially the polynomial basis algorithm for $n = 3$ except that the points  are 
+chosen such that $\zeta$ is easy to compute and the resulting system of equations easy to reduce.  In this algorithm the points $\zeta_{0}$, 
+$16 \cdot \zeta_{1 \over 2}$, $\zeta_1$, $\zeta_2$ and $\zeta_{\infty}$ make up the five requires points to solve for the coefficients of the
+product.  
 
-\bibitem[5]{KARA}
-A. Karatsuba, Doklay Akad. Nauk SSSR 145 (1962), pp.293-294
+At first glance the five coefficents are relatively efficient to compute with the exception of $16 \cdot \zeta{1 \over 2}$.  This coefficient
+is related to $\zeta_2 = (4a_2 + 2a_1 + a_0)(4b_2 + 2b_1 + b_0)$ in that the coefficients  of two terms are reversed (\textit{or mirrored}).  
+Simply put $16 \cdot \zeta{1 \over 2} = (a_2 + 2a_1 + 4a_0)(b_2 + 2b_1 + 4b_0)$.  
 
-\bibitem[6]{KARAP}
-Andre Weimerskirch and Christof Paar, \textit{Generalizations of the Karatsuba Algorithm for Polynomial Multiplication}, Submitted to Design, Codes and Cryptography, March 2002
+With the five relations that Toom has chosen the following system of equations is formed.
 
-\end{thebibliography}
+\begin{center}
+\begin{tabular}{rcrcrcrcrcr}
+$\zeta_0$                    & $=$ & $0w_4$ & $+$ & $0w_3$ & $+$ & $0w_2$ & $+$ & $0w_1$ & $+$ & $1w_0$  \\
+$16 \cdot \zeta_{1 \over 2}$ & $=$ & $1w_4$ & $+$ & $2w_3$ & $+$ & $4w_2$ & $+$ & $8w_1$ & $+$ & $16w_0$  \\
+$\zeta_1$                    & $=$ & $1w_4$ & $+$ & $1w_3$ & $+$ & $1w_2$ & $+$ & $1w_1$ & $+$ & $1w_0$  \\
+$\zeta_2$                    & $=$ & $16w_4$ & $+$ & $8w_3$ & $+$ & $4w_2$ & $+$ & $2w_1$ & $+$ & $1w_0$  \\
+$\zeta_{\infty}$             & $=$ & $1w_4$ & $+$ & $0w_3$ & $+$ & $0w_2$ & $+$ & $0w_1$ & $+$ & $0w_0$  \\
+\end{tabular}
+\end{center}
 
-\input{tommath.ind}
+A trivial solution to this matrix requires $12$ subtractions, two multiplications by a small power of two, two divisions by a small power
+of two, two divisions by three and one multiplication by three.  All of these $19$ sub-operations require less than quadratic time meaning that
+the algorithm overall can be faster than a baseline multiplication.  However, the greater complexity of this algorithm places the cutoff point
+(\textbf{TOOM\_MUL\_CUTOFF}) where Toom-Cook becomes the most efficient algorithm very much higher above the Karatsuba cutoff point.  
 
-\chapter{Appendix}
-\subsection*{Appendix A -- Source Listing of tommath.h}
+\subsection{Signed Multiplication}
+Now that algorithms to handle multiplications of every useful dimensions has been developed a rather simple finishing touch is required.  So far all
+of the multiplication algorithms have been unsigned which leaves only a signed multiplication algorithm to be established.  
 
-The following is the source listing of the header file ``tommath.h'' for the LibTomMath project.  It contains many of 
-the definitions used throughout the code such as \textbf{mp\_int}, \textbf{MP\_PREC} and so on.  The header is 
-presented here for completeness.
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_mul}. \\
+\textbf{Input}.   mp\_int $a$ and mp\_int $b$ \\
+\textbf{Output}.  $c \leftarrow a \cdot b$ \\
+\hline \\
+1.  If $a.sign = b.sign$ then \\
+\hspace{3mm}1.1  $sign = MP\_ZPOS$ \\
+2.  else \\
+\hspace{3mm}2.1  $sign = MP\_ZNEG$ \\
+3.  If min$(a.used, b.used) \ge TOOM\_MUL\_CUTOFF$ then  \\
+\hspace{3mm}3.1  $c \leftarrow a \cdot b$ using algorithm mp\_toom\_mul \\
+4.  else if min$(a.used, b.used) \ge KARATSUBA\_MUL\_CUTOFF$ then \\
+\hspace{3mm}4.1  $c \leftarrow a \cdot b$ using algorithm mp\_karatsuba\_mul \\
+5.  else \\
+\hspace{3mm}5.1  $digs \leftarrow a.used + b.used + 1$ \\
+\hspace{3mm}5.2  If $digs < MP\_ARRAY$ and min$(a.used, b.used) \le \delta$ then \\
+\hspace{6mm}5.2.1  $c \leftarrow a \cdot b \mbox{ (mod }\beta^{digs}\mbox{)}$ using algorithm fast\_s\_mp\_mul\_digs.  \\
+\hspace{3mm}5.3  else \\
+\hspace{6mm}5.3.1  $c \leftarrow a \cdot b \mbox{ (mod }\beta^{digs}\mbox{)}$ using algorithm s\_mp\_mul\_digs.  \\
+6.  $c.sign \leftarrow sign$ \\
+7.  Return the result of the unsigned multiplication performed. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_mul}
+\end{figure}
 
-\index{tommath.h}
+\textbf{Algorithm mp\_mul.}
+This algorithm performs the signed multiplication of two inputs.  It will make use of any of the three unsigned multiplication algorithms 
+available when the input is of appropriate size.  The \textbf{sign} of the result is not set until the end of the algorithm since algorithm
+s\_mp\_mul\_digs will clear it.  
+
+\index{bn\_mp\_mul.c}
 \vspace{+3mm}\begin{small}
-\hspace{-5.1mm}{\bf File}: tommath.h
+\hspace{-5.1mm}{\bf File}: bn\_mp\_mul.c
 \vspace{-3mm}
 \begin{alltt}
-001   /* LibTomMath, multiple-precision integer library -- Tom St Denis
+016   
+017   /* high level multiplication (handles sign) */
+018   int
+019   mp_mul (mp_int * a, mp_int * b, mp_int * c)
+020   \{
+021     int     res, neg;
+022     neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
+023     
+024     if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) \{
+025       res = mp_toom_mul(a, b, c);
+026     \} else if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) \{
+027       res = mp_karatsuba_mul (a, b, c);
+028     \} else \{
+029   
+030       /* can we use the fast multiplier?
+031        *
+032        * The fast multiplier can be used if the output will 
+033        * have less than MP_WARRAY digits and the number of 
+034        * digits won't affect carry propagation
+035        */
+036       int     digs = a->used + b->used + 1;
+037   
+038       if ((digs < MP_WARRAY) &&
+039           MIN(a->used, b->used) <= 
+040           (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
+041         res = fast_s_mp_mul_digs (a, b, c, digs);
+042       \} else \{
+043         res = s_mp_mul (a, b, c);
+044       \}
+045   
+046     \}
+047     c->sign = neg;
+048     return res;
+049   \}
+\end{alltt}
+\end{small}
+
+The implementation is rather simplistic and is not particularly noteworthy.  Line 22 computes the sign of the result using the ``?'' 
+operator from the C programming language.  Line 40 computes $\delta$ using the fact that $1 << k$ is equal to $2^k$.  
+
+\section{Squaring}
+
+Squaring is a special case of multiplication where both multiplicands are equal.  At first it may seem like there is no significant optimization
+available but in fact there is.  Consider the multiplication of $576$ against $241$.  In total there will be nine single precision multiplications
+performed which are $1\cdot 6$, $1 \cdot 7$, $1 \cdot 5$, $4 \cdot 6$, $4 \cdot 7$, $4 \cdot 5$, $2 \cdot  6$, $2 \cdot 7$ and $2 \cdot 5$.  Now consider 
+the multiplication of $123$ against $123$.  The nine products are $3 \cdot 3$, $3 \cdot 2$, $3 \cdot 1$, $2 \cdot 3$, $2 \cdot 2$, $2 \cdot 1$, 
+$1 \cdot 3$, $1 \cdot 2$ and $1 \cdot 1$.  On closer inspection some of the products are equivalent.  For example, $3 \cdot 2 = 2 \cdot 3$ 
+and $3 \cdot 1 = 1 \cdot 3$. 
+
+For any $n$-digit input there are ${{\left (n^2 + n \right)}\over 2}$ possible unique single precision multiplications required.  The following
+diagram demonstrates the operations required.
+
+\begin{figure}[here]
+\begin{center}
+\begin{tabular}{ccccc|c}
+&&1&2&3&\\
+$\times$ &&1&2&3&\\
+\hline && $3 \cdot 1$ & $3 \cdot 2$ & $3 \cdot 3$ & Row 0\\
+       & $2 \cdot 1$  & $2 \cdot 2$ & $2 \cdot 3$ && Row 1 \\
+         $1 \cdot 1$  & $1 \cdot 2$ & $1 \cdot 3$ &&& Row 2 \\
+\end{tabular}
+\end{center}
+\caption{Squaring Optimization Diagram}
+\end{figure}
+
+Starting from zero and numbering the columns from right to left a very simple pattern becomes obvious.  For the purposes of this discussion let $x$
+represent the number being squared.  The first observation is that in row $k$ the $2k$'th column of the product has a $\left (x_k \right)^2$ term in it.  
+
+The second observation is that every column $j$ in row $k$ where $j \ne 2k$ is part of a double product.  Every odd column is made up entirely of 
+double products.  In fact every column is made up of double products and at most one square (\textit{see the exercise section}).  
+
+The third and final observation is that for row $k$ the first unique non-square term occurs at column $2k + 1$.  For example, on row $1$ of the 
+previous squaring, column one is part of the double product with column one from row zero. Column two of row one is a square and column three is
+the first unique column.
+
+\subsection{The Baseline Squaring Algorithm}
+The baseline squaring algorithm is meant to be a catch-all squaring algorithm.  It will handle any of the input sizes that the faster routines
+will not handle.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{s\_mp\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+1.  Init a temporary mp\_int of at least $2 \cdot a.used +1$ digits.  (\textit{mp\_init\_size}) \\
+2.  If step 1 failed return(\textit{MP\_MEM}) \\
+3.  $t.used \leftarrow 2 \cdot a.used + 1$ \\
+4.  For $ix$ from 0 to $a.used - 1$ do \\
+\hspace{3mm}Calculate the square. \\
+\hspace{3mm}4.1  $\hat r \leftarrow t_{2ix} + \left (a_{ix} \right )^2$ \\
+\hspace{3mm}4.2  $t_{2ix} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}Calculate the double products after the square. \\
+\hspace{3mm}4.3  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+\hspace{3mm}4.4  For $iy$ from $ix + 1$ to $a.used - 1$ do \\
+\hspace{6mm}4.4.1  $\hat r \leftarrow 2 \cdot a_{ix}a_{iy} + t_{ix + iy} + u$ \\
+\hspace{6mm}4.4.2  $t_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{6mm}4.4.3  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+\hspace{3mm}Set the last carry. \\
+\hspace{3mm}4.5  While $u > 0$ do \\
+\hspace{6mm}4.5.1  $iy \leftarrow iy + 1$ \\
+\hspace{6mm}4.5.2  $\hat r \leftarrow t_{ix + iy} + u$ \\
+\hspace{6mm}4.5.3  $t_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{6mm}4.5.4  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+5.  Clamp excess digits of $t$.  (\textit{mp\_clamp}) \\
+6.  Exchange $b$ and $t$. \\
+7.  Clear $t$ (\textit{mp\_clear}) \\
+8.  Return(\textit{MP\_OKAY}) \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm s\_mp\_sqr}
+\end{figure}
+
+\textbf{Algorithm s\_mp\_sqr.}
+This algorithm computes the square of an input using the three observations on squaring.  It is based fairly faithfully on  algorithm 14.16 of 
+\cite[pp.596-597]{HAC}.  Similar to algorithm s\_mp\_mul\_digs a temporary mp\_int is allocated to hold the result of the squaring.  This allows the 
+destination mp\_int to be the same as the source mp\_int without losing information part way through the squaring.
+
+The outer loop of this algorithm begins on step 4. It is best to think of the outer loop as walking down the rows of the partial results while
+the inner loop computes the columns of the partial result.  Step 4.1 and 4.2 compute the square term for each row while step 4.3 and 4.4 propagate
+the carry and compute the double products.  
+
+The requirement that a mp\_word be able to represent the range $0 \le x < 2 \beta^2$ arises from this
+very algorithm.  The product $a_{ix}a_{iy}$ will lie in the range $0 \le x \le \beta^2 - 2\beta + 1$ which is obviously less than $\beta^2$ meaning that
+when it is multiply by two it can be represented by a mp\_word properly.
+
+Similar to algorithm s\_mp\_mul\_digs after every pass of the inner loop the destination is correctly set to the sum of all of the partial 
+results calculated so far.  This involves expensive carry propagation which will be eliminated shortly.  
+
+\index{bn\_s\_mp\_sqr.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_sqr.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */
+018   int
+019   s_mp_sqr (mp_int * a, mp_int * b)
+020   \{
+021     mp_int  t;
+022     int     res, ix, iy, pa;
+023     mp_word r;
+024     mp_digit u, tmpx, *tmpt;
+025   
+026     pa = a->used;
+027     if ((res = mp_init_size (&t, pa + pa + 1)) != MP_OKAY) \{
+028       return res;
+029     \}
+030     t.used = pa + pa + 1;
+031   
+032     for (ix = 0; ix < pa; ix++) \{
+033       /* first calculate the digit at 2*ix */
+034       /* calculate double precision result */
+035       r = ((mp_word) t.dp[ix + ix]) + 
+036           ((mp_word) a->dp[ix]) * ((mp_word) a->dp[ix]);
+037   
+038       /* store lower part in result */
+039       t.dp[ix + ix] = (mp_digit) (r & ((mp_word) MP_MASK));
+040   
+041       /* get the carry */
+042       u = (r >> ((mp_word) DIGIT_BIT));
+043   
+044       /* left hand side of A[ix] * A[iy] */
+045       tmpx = a->dp[ix];
+046   
+047       /* alias for where to store the results */
+048       tmpt = t.dp + (ix + ix + 1);
+049       
+050       for (iy = ix + 1; iy < pa; iy++) \{
+051         /* first calculate the product */
+052         r = ((mp_word) tmpx) * ((mp_word) a->dp[iy]);
+053   
+054         /* now calculate the double precision result, note we use
+055          * addition instead of *2 since its easier to optimize
+056          */
+057         r = ((mp_word) * tmpt) + r + r + ((mp_word) u);
+058   
+059         /* store lower part */
+060         *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
+061   
+062         /* get carry */
+063         u = (r >> ((mp_word) DIGIT_BIT));
+064       \}
+065       /* propagate upwards */
+066       while (u != ((mp_digit) 0)) \{
+067         r = ((mp_word) * tmpt) + ((mp_word) u);
+068         *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK));
+069         u = (r >> ((mp_word) DIGIT_BIT));
+070       \}
+071     \}
+072   
+073     mp_clamp (&t);
+074     mp_exch (&t, b);
+075     mp_clear (&t);
+076     return MP_OKAY;
+077   \}
+\end{alltt}
+\end{small}
+
+Inside the outer loop (\textit{see line 32}) the square term is calculated on line 35.  Line 42 extracts the carry from the square
+term.  Aliases for $a_{ix}$ and $t_{ix+iy}$ are initialized on lines 45 and 48 respectively.  The doubling is performed using two
+additions (\textit{see line 57}) since it is usually faster than shifting if not at least as fast.  
+
+\subsection{Faster Squaring by the ``Comba'' Method}
+A major drawback to the baseline method is the requirement for single precision shifting inside the $O(n^2)$ work level.  Squaring has an additional
+drawback that it must double the product inside the inner loop as well.  As for multiplication the Comba technique can be used to eliminate these
+performance hazards.
+
+The first obvious solution is to make an array of mp\_words which will hold all of the columns.  This will indeed eliminate all of the carry
+propagation operations from the inner loop.  However, the inner product must still be doubled $O(n^2)$ times.  The solution stems from the simple fact
+that $2a + 2b + 2c = 2(a + b + c)$.  That is the sum of all of the double products is equal to double the sum of all the products.  For example,
+$ab + ba + ac + ca = 2ab + 2ac = 2(ab + ac)$.  
+
+However, we cannot simply double all of the columns since the squares appear only once per row.  The most practical solution is to have two mp\_word
+arrays.  One array will hold the squares and the other array will hold the double products.  With both arrays the doubling and carry propagation can be 
+moved to a $O(n)$ work level outside the $O(n^2)$ level.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{fast\_s\_mp\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+Place two arrays of \textbf{MP\_WARRAY} mp\_words named $\hat W$ and $\hat {X}$ on the stack. \\
+1.  If $b.alloc < 2a.used + 1$ then grow $b$ to $2a.used + 1$ digits.  (\textit{mp\_grow}). \\
+2.  If step 1 failed return(\textit{MP\_MEM}). \\
+3.  for $ix$ from $0$ to $2a.used + 1$ do \\
+\hspace{3mm}3.1  $\hat W_{ix} \leftarrow 0$ \\
+\hspace{3mm}3.2  $\hat {X}_{ix} \leftarrow 0$ \\
+4.  for $ix$ from $0$ to $a.used - 1$ do \\
+\hspace{3mm}Compute the square.\\
+\hspace{3mm}4.1  $\hat {X}_{ix+ix} \leftarrow \left ( a_ix \right )^2$ \\
+\hspace{3mm}Compute the double products.\\
+\hspace{3mm}4.2  for $iy$ from $ix + 1$ to $a.used - 1$ do \\
+\hspace{6mm}4.2.1  $\hat W_{ix+iy} \leftarrow \hat W_{ix+iy} + a_{ix}a_{iy}$ \\
+5.  $oldused \leftarrow b.used$ \\
+6.  $b.used \leftarrow 2a.used + 1$ \\
+Double the products and propagate the carries simultaneously. \\
+7.  $\hat W_0 \leftarrow 2 \hat W_0 + \hat {X}_0$ \\
+8.  for $ix$ from $1$ to $2a.used$ do \\
+\hspace{3mm}8.1 $\hat W_{ix} \leftarrow 2 \hat W_{ix} + \hat {X}_{ix}$ \\
+\hspace{3mm}8.2 $\hat W_{ix} \leftarrow \hat W_{ix} + \lfloor \hat W_{ix - 1} / \beta \rfloor$ \\
+\hspace{3mm}8.3 $b_{ix-1} \leftarrow W_{ix-1} \mbox{ (mod }\beta\mbox{)}$ \\
+9.  $b_{2a.used} \leftarrow \hat W_{2a.used} \mbox{ (mod }\beta\mbox{)}$ \\
+10.  if $2a.used + 1 < oldused$ then do \\
+\hspace{3mm}10.1  for $ix$ from $2a.used + 1$ to $oldused$ do \\
+\hspace{6mm}10.1.1  $b_{ix} \leftarrow 0$ \\
+11.  Clamp excess digits from $b$.  (\textit{mp\_clamp}) \\
+12.  Return(\textit{MP\_OKAY}). \\ 
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm fast\_s\_mp\_sqr}
+\end{figure}
+
+\textbf{Algorithm fast\_s\_mp\_sqr.}
+This algorithm computes the square of an input using the Comba technique.  It is designed to be a replacement for algorithm s\_mp\_sqr when
+the amount of input digits is less than \textbf{MP\_WARRAY} and less than $\delta \over 2$.  
+
+This routine requires two arrays of mp\_words to be placed on the stack.  The first array $\hat W$ will hold the double products and the second
+array $\hat X$ will hold the squares.  Though only at most $MP\_WARRAY \over 2$ words of $\hat X$ are used it has proven faster on most 
+processors to simply make it a full size array.
+
+The loop on step 3 will zero the two arrays to prepare them for the squaring step.  Step 4.1 computes the squares of the product.  Note how 
+it simply assigns the value into the $\hat X$ array.  The nested loop on step 4.2 computes the doubles of the products.  In actuality that loop
+computes the sum of the products for each column.  They are not doubled until later.
+
+After the squaring loop the products stored in $\hat W$ musted be doubled and the carries propagated forwards.  It makes sense to do both
+operations at the same time.  The expression $\hat W_{ix} \leftarrow 2 \hat W_{ix} + \hat {X}_{ix}$ computes the sum of the double product and the
+squares in place.  
+
+\index{bn\_fast\_s\_mp\_sqr.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_fast\_s\_mp\_sqr.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* fast squaring
+018    *
+019    * This is the comba method where the columns of the product 
+020    * are computed first then the carries are computed.  This 
+021    * has the effect of making a very simple inner loop that 
+022    * is executed the most
+023    *
+024    * W2 represents the outer products and W the inner.
+025    *
+026    * A further optimizations is made because the inner 
+027    * products are of the form "A * B * 2".  The *2 part does 
+028    * not need to be computed until the end which is good 
+029    * because 64-bit shifts are slow!
+030    *
+031    * Based on Algorithm 14.16 on pp.597 of HAC.
+032    *
+033    */
+034   int
+035   fast_s_mp_sqr (mp_int * a, mp_int * b)
+036   \{
+037     int     olduse, newused, res, ix, pa;
+038     mp_word W2[MP_WARRAY], W[MP_WARRAY];
+039   
+040     /* calculate size of product and allocate as required */
+041     pa = a->used;
+042     newused = pa + pa + 1;
+043     if (b->alloc < newused) \{
+044       if ((res = mp_grow (b, newused)) != MP_OKAY) \{
+045         return res;
+046       \}
+047     \}
+048   
+049     /* zero temp buffer (columns)
+050      * Note that there are two buffers.  Since squaring requires
+051      * a outter and inner product and the inner product requires
+052      * computing a product and doubling it (a relatively expensive
+053      * op to perform n**2 times if you don't have to) the inner and
+054      * outer products are computed in different buffers.  This way
+055      * the inner product can be doubled using n doublings instead of
+056      * n**2
+057      */
+058     memset (W, 0, newused * sizeof (mp_word));
+059     memset (W2, 0, newused * sizeof (mp_word));
+060   
+061     /* This computes the inner product.  To simplify the inner N**2 loop
+062      * the multiplication by two is done afterwards in the N loop.
+063      */
+064     for (ix = 0; ix < pa; ix++) \{
+065       /* compute the outer product
+066        *
+067        * Note that every outer product is computed
+068        * for a particular column only once which means that
+069        * there is no need todo a double precision addition
+070        */
+071       W2[ix + ix] = ((mp_word) a->dp[ix]) * ((mp_word) a->dp[ix]);
+072   
+073       \{
+074         register mp_digit tmpx, *tmpy;
+075         register mp_word *_W;
+076         register int iy;
+077   
+078         /* copy of left side */
+079         tmpx = a->dp[ix];
+080   
+081         /* alias for right side */
+082         tmpy = a->dp + (ix + 1);
+083   
+084         /* the column to store the result in */
+085         _W = W + (ix + ix + 1);
+086   
+087         /* inner products */
+088         for (iy = ix + 1; iy < pa; iy++) \{
+089             *_W++ += ((mp_word) tmpx) * ((mp_word) * tmpy++);
+090         \}
+091       \}
+092     \}
+093   
+094     /* setup dest */
+095     olduse  = b->used;
+096     b->used = newused;
+097   
+098     /* now compute digits */
+099     \{
+100       register mp_digit *tmpb;
+101   
+102       /* double first value, since the inner products are 
+103        * half of what they should be 
+104        */
+105       W[0] += W[0] + W2[0];
+106   
+107       tmpb = b->dp;
+108       for (ix = 1; ix < newused; ix++) \{
+109         /* double/add next digit */
+110         W[ix] += W[ix] + W2[ix];
+111   
+112         W[ix] = W[ix] + (W[ix - 1] >> ((mp_word) DIGIT_BIT));
+113         *tmpb++ = (mp_digit) (W[ix - 1] & ((mp_word) MP_MASK));
+114       \}
+115       /* set the last value.  Note even if the carry is zero 
+116        * this is required since the next step will not zero 
+117        * it if b originally had a value at b->dp[2*a.used]
+118        */
+119       *tmpb++ = (mp_digit) (W[(newused) - 1] & ((mp_word) MP_MASK));
+120   
+121       /* clear high digits */
+122       for (; ix < olduse; ix++) \{
+123         *tmpb++ = 0;
+124       \}
+125     \}
+126   
+127     mp_clamp (b);
+128     return MP_OKAY;
+129   \}
+\end{alltt}
+\end{small}
+
+-- Write something deep and insightful later, Tom.
+
+\subsection{Polynomial Basis Squaring}
+The same algorithm that performs optimal polynomial basis multiplication can be used to perform polynomial basis squaring.  The minor exception
+is that $\zeta_y = f(y) \cdot g(y)$ is actually equivalent to $\zeta_y = f(y)^2$ since $f(y) = g(y)$.  That is instead of performing $2n + 1$
+multiplications to find the $\zeta$ relations squaring operations are performed instead.  
+
+\subsection{Karatsuba Squaring}
+Let $f(x) = ax + b$ represent the polynomial basis representation of a number to square.  
+Let $h(x) = \left ( f(x) \right )^2$ represent the square of the polynomial.  The Karatsuba equation can be modified to square a 
+number with the following equation.
+
+\begin{equation}
+h(x) = a^2x^2 + \left (a^2 + b^2 - (a - b)^2 \right )x + b^2
+\end{equation}
+
+Upon closer inspection this equation only requires the calculation of three half-sized squares: $a^2$, $b^2$ and $(a - b)^2$.  As in 
+Karatsuba multiplication this algorithm can be applied recursively on the input and will achieve an asymptotic running time of 
+$O \left ( n^{lg(3)} \right )$.
+
+If the asymptotic time of Karatsuba squaring and multiplication is the same why not simply use the multiplication algorithm instead?  The answer
+to this question arises from the cutoff point for squaring.  As in multiplication there exists a cutoff point at which the time required for a 
+Comba based squaring and a Karatsuba based squaring meet.  Due to the overhead inherent in the Karatsuba method the cutoff point is fairly 
+high.  For example, on an Athlon processor with $\beta = 2^{28}$ the cutoff point is around 127 digits.  
+
+Consider squaring a 200 digit number with this technique.  It will be split into two 100 digit halves which are subsequently squared.  
+The 100 digit numbers will not be squared using Karatsuba but instead the faster Comba based squaring algorithm.  If Karatsuba multiplication
+were used instead the 100 digit numbers would be squared with a slower Comba based multiplication.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_karatsuba\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+1.  Initialize the following temporary mp\_ints:  $x0$, $x1$, $t1$, $t2$, $x0x0$ and $x1x1$. \\
+2.  If any of the initializations on step 1 failed return(\textit{MP\_MEM}). \\
+\\
+Split the input.  e.g. $a = x1\beta^B + x0$ \\
+3.  $B \leftarrow a.used / 2$ \\
+4.  $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{mp\_mod\_2d}) \\
+5.  $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{mp\_lshd}) \\
+\\
+Calculate the three squares. \\
+6.  $x0x0 \leftarrow x0^2$ (\textit{mp\_sqr}) \\
+7.  $x1x1 \leftarrow x1^2$ \\
+8.  $t1 \leftarrow x1 - x0$ (\textit{mp\_sub}) \\
+9.  $t1 \leftarrow t1^2$ \\
+\\
+Compute the middle term. \\
+10.  $t2 \leftarrow x0x0 + x1x1$ (\textit{s\_mp\_add}) \\
+11.  $t1 \leftarrow t2 - t1$ \\
+\\
+Compute final product. \\
+12.  $t1 \leftarrow t1\beta^B$ (\textit{mp\_lshd}) \\
+13.  $x1x1 \leftarrow x1x1\beta^{2B}$ \\
+14.  $t1 \leftarrow t1 + x0x0$ \\
+15.  $b \leftarrow t1 + x1x1$ \\
+16.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_karatsuba\_sqr}
+\end{figure}
+
+\textbf{Algorithm mp\_karatsuba\_sqr.}
+This algorithm computes the square of an input $a$ using the Karatsuba technique.  This algorithm is very much similar to the Karatsuba based
+multiplication algorithm.  
+
+The radix point for squaring is simply the placed above the median of the digits.  Step 3, 4 and 5 compute the two halves required using $B$
+as the radix point.  The first two squares in steps 6 and 7 are rather straightforward while the last square is in a more compact form.
+
+By expanding $\left (x1 - x0 \right )^2$ the $x1^2$ and $x0^2$ terms in the middle disappear, that is $x1^2 + x0^2 - (x1 - x0)^2 = 2 \cdot x0 \cdot x1$.
+Now if $5n$ single precision additions and a squaring of $n$-digits is faster than multiplying two $n$-digit numbers and doubling then
+this method is faster.  Assuming no further recursions occur the difference can be estimated.
+
+Let $p$ represent the cost of a single precision addition and $q$ the cost of a single precision multiplication both in terms of time\footnote{Or
+machine clock cycles.}.  The question reduces to whether the following equation is true or not.
+
+\begin{equation}
+5np +{{q(n^2 + n)} \over 2} \le pn + qn^2
+\end{equation}
+
+For example, on an AMD Athlon processor $p = {1 \over 3}$ and $q = 6$.  This implies that the following inequality should hold.
+\begin{center}
+\begin{tabular}{rcl}
+$5n + 3n^2 + 3n$     & $<$ & ${n \over 3} + 6n^2$ \\
+${25 \over 3} + 3n$  & $<$ & ${1 \over 3} + 6n$ \\
+${25 \over 3}$       & $<$ & $3n$ \\
+${25 \over 9}$       & $<$ & $n$ \\
+\end{tabular}
+\end{center}
+
+This results in a cutoff point around $n = 3$.  As a consequence it is actually faster to compute the middle term the ``long way'' on processors
+where multiplication is substantially slower\footnote{On the Athlon there is a 1:17 ratio between clock cycles for addition and multiplication.  On
+the Intel P4 processor this ratio is 1:29 making this method even more beneficial.  The only common exception is the ARMv4 processor which has a
+ratio of 1:7.  } than simpler operations such as addition.  
+
+\index{bn\_mp\_karatsuba\_sqr.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_karatsuba\_sqr.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* Karatsuba squaring, computes b = a*a using three 
+018    * half size squarings
+019    *
+020    * See comments of mp_karatsuba_mul for details.  It 
+021    * is essentially the same algorithm but merely 
+022    * tuned to perform recursive squarings.
+023    */
+024   int
+025   mp_karatsuba_sqr (mp_int * a, mp_int * b)
+026   \{
+027     mp_int  x0, x1, t1, t2, x0x0, x1x1;
+028     int     B, err;
+029   
+030     err = MP_MEM;
+031   
+032     /* min # of digits */
+033     B = a->used;
+034   
+035     /* now divide in two */
+036     B = B / 2;
+037   
+038     /* init copy all the temps */
+039     if (mp_init_size (&x0, B) != MP_OKAY)
+040       goto ERR;
+041     if (mp_init_size (&x1, a->used - B) != MP_OKAY)
+042       goto X0;
+043   
+044     /* init temps */
+045     if (mp_init_size (&t1, a->used * 2) != MP_OKAY)
+046       goto X1;
+047     if (mp_init_size (&t2, a->used * 2) != MP_OKAY)
+048       goto T1;
+049     if (mp_init_size (&x0x0, B * 2) != MP_OKAY)
+050       goto T2;
+051     if (mp_init_size (&x1x1, (a->used - B) * 2) != MP_OKAY)
+052       goto X0X0;
+053   
+054     \{
+055       register int x;
+056       register mp_digit *dst, *src;
+057   
+058       src = a->dp;
+059   
+060       /* now shift the digits */
+061       dst = x0.dp;
+062       for (x = 0; x < B; x++) \{
+063         *dst++ = *src++;
+064       \}
+065   
+066       dst = x1.dp;
+067       for (x = B; x < a->used; x++) \{
+068         *dst++ = *src++;
+069       \}
+070     \}
+071   
+072     x0.used = B;
+073     x1.used = a->used - B;
+074   
+075     mp_clamp (&x0);
+076   
+077     /* now calc the products x0*x0 and x1*x1 */
+078     if (mp_sqr (&x0, &x0x0) != MP_OKAY)
+079       goto X1X1;           /* x0x0 = x0*x0 */
+080     if (mp_sqr (&x1, &x1x1) != MP_OKAY)
+081       goto X1X1;           /* x1x1 = x1*x1 */
+082   
+083     /* now calc (x1-x0)**2 */
+084     if (mp_sub (&x1, &x0, &t1) != MP_OKAY)
+085       goto X1X1;           /* t1 = x1 - x0 */
+086     if (mp_sqr (&t1, &t1) != MP_OKAY)
+087       goto X1X1;           /* t1 = (x1 - x0) * (x1 - x0) */
+088   
+089     /* add x0y0 */
+090     if (s_mp_add (&x0x0, &x1x1, &t2) != MP_OKAY)
+091       goto X1X1;           /* t2 = x0x0 + x1x1 */
+092     if (mp_sub (&t2, &t1, &t1) != MP_OKAY)
+093       goto X1X1;           /* t1 = x0x0 + x1x1 - (x1-x0)*(x1-x0) */
+094   
+095     /* shift by B */
+096     if (mp_lshd (&t1, B) != MP_OKAY)
+097       goto X1X1;           /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */
+098     if (mp_lshd (&x1x1, B * 2) != MP_OKAY)
+099       goto X1X1;           /* x1x1 = x1x1 << 2*B */
+100   
+101     if (mp_add (&x0x0, &t1, &t1) != MP_OKAY)
+102       goto X1X1;           /* t1 = x0x0 + t1 */
+103     if (mp_add (&t1, &x1x1, b) != MP_OKAY)
+104       goto X1X1;           /* t1 = x0x0 + t1 + x1x1 */
+105   
+106     err = MP_OKAY;
+107   
+108   X1X1:mp_clear (&x1x1);
+109   X0X0:mp_clear (&x0x0);
+110   T2:mp_clear (&t2);
+111   T1:mp_clear (&t1);
+112   X1:mp_clear (&x1);
+113   X0:mp_clear (&x0);
+114   ERR:
+115     return err;
+116   \}
+\end{alltt}
+\end{small}
+
+This implementation is largely based on the implementation of algorithm mp\_karatsuba\_mul.  It uses the same inline style to copy and 
+shift the input into the two halves.  The loop from line 54 to line 70 has been modified since only one input exists.  The \textbf{used}
+count of both $x0$ and $x1$ is fixed up and $x0$ is clamped before the calculations begin.  At this point $x1$ and $x0$ are valid equivalents
+to the respective halves as if mp\_rshd and mp\_mod\_2d had been used.  
+
+By inlining the copy and shift operations the cutoff point for Karatsuba multiplication can be lowered.  On the Athlon the cutoff point
+is exactly at the point where Comba squaring can no longer be used (\textit{128 digits}).  On slower processors such as the Intel P4
+it is actually below the Comba limit (\textit{at 110 digits}).
+
+This routine uses the same error trap coding style as mp\_karatsuba\_sqr.  As the temporary variables are initialized errors are redirected to
+the error trap higher up.  If the algorithm completes without error the error code is set to \textbf{MP\_OKAY} and the error traps are 
+executed.
+
+\textit{Last paragraph sucks.  re-write! -- Tom}
+
+\subsection{Toom-Cook Squaring}
+The Toom-Cook squaring algorithm mp\_toom\_sqr is heavily based on the algorithm mp\_toom\_mul with the minor exception noted.  The reader is 
+encouraged to read the description of the latter algorithm and try to derive their own Toom-Cook squaring algorithm.  
+
+\subsection{Generic Squaring}
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_sqr}. \\
+\textbf{Input}.   mp\_int $a$ \\
+\textbf{Output}.  $b \leftarrow a^2$ \\
+\hline \\
+1.  If $a.used \ge TOOM\_SQR\_CUTOFF$ then  \\
+\hspace{3mm}1.1  $b \leftarrow a^2$ using algorithm mp\_toom\_sqr \\
+2.  else if $a.used \ge KARATSUBA\_SQR\_CUTOFF$ then \\
+\hspace{3mm}2.1  $b \leftarrow a^2$ using algorithm mp\_karatsuba\_sqr \\
+3.  else \\
+\hspace{3mm}3.1  $digs \leftarrow a.used + b.used + 1$ \\
+\hspace{3mm}3.2  If $digs < MP\_ARRAY$ and $a.used \le \delta$ then \\
+\hspace{6mm}3.2.1  $b \leftarrow a^2$ using algorithm fast\_s\_mp\_sqr.  \\
+\hspace{3mm}3.3  else \\
+\hspace{6mm}3.3.1  $b \leftarrow a^2$ using algorithm s\_mp\_sqr.  \\
+4.  $b.sign \leftarrow MP\_ZPOS$ \\
+5.  Return the result of the unsigned squaring performed. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_sqr}
+\end{figure}
+
+\textbf{Algorithm mp\_sqr.}
+This algorithm computes the square of the input using one of four different algorithms.  If the input is very large and has at least
+\textbf{TOOM\_SQR\_CUTOFF} or \textbf{KARATSUBA\_SQR\_CUTOFF} digits then either the Toom-Cook or the Karatsuba Squaring algorithm is used.  If
+neither of the polynomial basis algorithms should be used then either the Comba or baseline algorithm is used.  
+
+\index{bn\_mp\_sqr.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_sqr.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* computes b = a*a */
+018   int
+019   mp_sqr (mp_int * a, mp_int * b)
+020   \{
+021     int     res;
+022     if (a->used >= TOOM_SQR_CUTOFF) \{
+023       res = mp_toom_sqr(a, b);
+024     \} else if (a->used >= KARATSUBA_SQR_CUTOFF) \{
+025       res = mp_karatsuba_sqr (a, b);
+026     \} else \{
+027   
+028       /* can we use the fast multiplier? */
+029       if ((a->used * 2 + 1) < MP_WARRAY && 
+030            a->used < 
+031            (1 << (sizeof(mp_word) * CHAR_BIT - 2*DIGIT_BIT - 1))) \{
+032         res = fast_s_mp_sqr (a, b);
+033       \} else \{
+034         res = s_mp_sqr (a, b);
+035       \}
+036     \}
+037     b->sign = MP_ZPOS;
+038     return res;
+039   \}
+\end{alltt}
+\end{small}
+
+\section*{Exercises}
+\begin{tabular}{cl}
+$\left [ 3 \right ] $ & Devise an efficient algorithm for selection of the radix point to handle inputs \\
+                      & that have different number of digits in Karatsuba multiplication. \\
+                      & \\
+$\left [ 3 \right ] $ & In section 6.3 the fact that every column of a squaring is made up \\
+                      & of double products and at most one square is stated.  Prove this statement. \\
+                      & \\                      
+$\left [ 2 \right ] $ & In the Comba squaring algorithm half of the $\hat X$ variables are not used. \\
+                      & Revise algorithm fast\_s\_mp\_sqr to shrink the $\hat X$ array. \\
+                      & \\
+$\left [ 3 \right ] $ & Prove the equation for Karatsuba squaring. \\
+                      & \\
+$\left [ 1 \right ] $ & Prove that Karatsuba squaring requires $O \left (n^{lg(3)} \right )$ time. \\
+                      & \\ 
+$\left [ 2 \right ] $ & Determine the minimal ratio between addition and multiplication clock cycles \\
+                      & required for equation $6.7$ to be true.  \\
+                      & \\
+\end{tabular}
+
+\chapter{Modular Reduction}
+\section{Basics of Modular Reduction}
+\index{modular residue}
+Modular reduction is an operation that arises quite often within public key cryptography algorithms.  A number is said to be reduced modulo another
+number by finding the remainder of division.  If an integer $a$ is reduced modulo $b$ that is to solve the equation $a = bq + p$ then $p$ is the 
+result.  To phrase that another way ``$p$ is congruent to $a$ modulo $b$'' which is also written as $p \equiv a \mbox{ (mod }b\mbox{)}$.  In
+other vernacular $p$ is known as the ``modular residue'' which leads to ``quadratic residue''\footnote{That's fancy talk for $b \equiv a^2 \mbox{ (mod }p\mbox{)}$.} and
+other forms of residues.  
+
+\index{modulus}
+Modular reductions are normally used to form finite groups such as fields and rings.  For example, in the RSA public key algorithm \cite{RSAPAPER} 
+two private primes $p$ and $q$ are chosen which when multiplied $n = pq$ forms a composite modulus.  When operations such as multiplication and
+squaring are performed on units of the ring $\Z_n$ a finite multiplicative sub-group is formed.  This sub-group is the group used to perform RSA
+operations.  Do not worry to much about how RSA works as it is not important for this discussion.   
+
+The most common usage for performance driven modular reductions is in modular exponentiation algorithms.  That is to compute 
+$d = a^b \mbox{ (mod }c\mbox{)}$ as fast as possible.  As will be discussed in the subsequent chapter there exists fast algorithms for computing
+modular exponentiations without having to perform (\textit{in this example}) $b$ multiplications.  These algorithms will produce partial
+results in the range $0 \le x < c^2$ which can be taken advantage of.  
+
+The obvious line of thinking is to use an integer division routine and just extract the remainder.  While this is equivalent to finding the 
+modular residue it turns out that the limited range of the input can be exploited to create several efficient algorithms.  
+
+\section{The Barrett Reduction}
+The Barrett reduction algorithm \cite{BARRETT} was inspired by fast division algorithms which multiply by the reciprocal to emulate
+division.  Barretts observation was that the residue $c$ of $a$ modulo $b$ is equal to 
+
+\begin{equation}
+c = a - b \cdot \lfloor a/b \rfloor
+\end{equation}
+
+Since algorithms such as modular reduction would be using the same modulus extensively, using typical DSP intuition the next step would be to 
+replace $a/b$ with a multiplication by the reciprocal.  However, DSP intuition on its own will not work as these numbers are considerably
+larger than the precision of common DSP floating point data types.  It would take another common optimization to optimize the algorithm.
+
+\subsection{Fixed Point Arithmetic}
+The trick used to optimize the above equation is based on a technique of emulating floating point data types with fixed precision integers.  Fixed
+point arithmetic would be vastly popularlized in the mid 1990s for bringing 3d-games to the mass market.  The idea is to take a normal $k$-bit 
+integer data type and break it into $p$-bit integer and a $q$-bit fraction part (\textit{where $p+q = k$}).  
+
+In this system a $k$-bit integer $n$ would actually represent $n/2^q$.  For example, with $q = 4$ the integer $n = 37$ would actually represent the
+value $2.3125$.  To multiply two fixed point numbers the integers are multiplied using traditional arithmetic and subsequently normalized. For example, 
+with $q = 4$ to multiply the integers $9$ and $5$ they must be converted to fixed point first by multiplying by $2^q$.  Let $a = 9(2^q)$ 
+represent the fixed point representation of $9$ and $b = 5(2^q)$ represent the fixed point representation of $5$.  The product $ab$ is equal to
+$45(2^{2q})$ which when normalized produces $45(2^q)$.  
+
+Using fixed point arithmetic division can be easily achieved by multiplying by the reciprocal.  If $2^q$ is equivalent to one than $2^q/b$ is 
+equivalent to $1/b$ using real arithmetic.  Using this fact dividing an integer $a$ by another integer $b$ can be achieved with the following
+expression.
+
+\begin{equation}
+\lfloor (a \cdot (\lfloor 2^q / b \rfloor))/2^q \rfloor
+\end{equation}
+
+The precision of the division is proportional to the value of $q$.  If the divisor $b$ is used frequently as is the case with 
+modular exponentiation pre-computing $2^q/b$ will allow a division to be performed with a multiplication and a right shift.  Both operations
+are considerably faster than division on most processors.  
+
+Consider dividing $19$ by $5$.  The correct result is $\lfloor 19/5 \rfloor = 3$.  With $q = 3$ the reciprocal is $\lfloor 2^q/5 \rfloor = 1$ which
+leads to a product of $19$ which when divided by $2^q$ produces $2$.  However, with $q = 4$ the reciprocal is $\lfloor 2^q/5 \rfloor = 3$ and
+the result of the emulated division is $\lfloor 3 \cdot 19 / 2^q \rfloor = 3$ which is correct.  
+
+Plugging this form of divison into the original equation the following modular residue equation arises.
+
+\begin{equation}
+c = a - b \cdot \lfloor (a \cdot (\lfloor 2^q / b \rfloor))/2^q \rfloor
+\end{equation}
+
+Using the notation from \cite{BARRETT} the value of $\lfloor 2^q / b \rfloor$ will be represented by the $\mu$ symbol.  Using the $\mu$
+variable also helps re-inforce the idea that it is meant to be computed once and re-used.
+
+\begin{equation}
+c = a - b \cdot \lfloor (a \cdot \mu)/2^q \rfloor
+\end{equation}
+
+Provided that $2^q > b^2$ this algorithm will produce a quotient that is either exactly correct or off by a value of one.  Let $n$ represent
+the number of digits in $b$.  This algorithm requires approximately $2n^2$ single precision multiplications to produce the quotient and 
+another $n^2$ single precision multiplications to find the residue.  In total $3n^2$ single precision multiplications are required to 
+reduce the number.  
+
+For example, if $b = 1179677$ and $q = 41$ ($2^q > b^2$), then the reciprocal $\mu$ is equal to $\lfloor 2^q / b \rfloor = 1864089$.  Consider reducing
+$a = 180388626447$ modulo $b$ using the above reduction equation.  Using long division the quotient $\lfloor a/b \rfloor$ is equal
+to the quotient found using the fixed point method.  In this case the quotient is $\lfloor (a \cdot \mu)/2^q \rfloor = 152913$ and can
+produce the modular residue $a - 152913b = 677346$.
+
+\subsection{Choosing a Radix Point}
+Using the fixed point representation a modular reduction can be performed with $3n^2$ single precision multiplications.  If that were the best
+that could be achieved a full division might as well be used in its place.  The key to optimizing the reduction is to reduce the precision of
+the initial multiplication that finds the quotient.  
+
+Let $a$ represent the number of which the residue is sought.  Let $b$ represent the modulus used to find the residue.  Let $m$ represent
+the number of digits in $b$.  For the purposes of this discussion we will assume that the number of digits in $a$ is $2m$.  Dividing $a$ by 
+$b$ is the same as dividing a $2m$ digit integer by a $m$ digit integer.  Digits below the $m - 1$'th digit of $a$ will contribute at most a value
+of $1$ to the quotient because $\beta^k < b$ for any $0 \le k \le m - 1$.  
+
+Since those digits do not contribute much to the quotient the observation is that they might as well be zero.  However, if the digits 
+``might as well be zero'' they might as well not be there in the first place.  Let $q_0 = \lfloor a/\beta^{m-1} \rfloor$ represent the input
+with the zeroes trimmed.  Now the modular reduction is trimmed to the almost equivalent equation
+
+\begin{equation}
+c = a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor
+\end{equation}
+
+Notice how the original divisor $2^q$ has been replaced with $\beta^{m+1}$. Also note how the exponent on the divisor $m+1$ when added to the amount $q_0$
+was shifted by ($m-1$) equals $2m$.  If the optimization had not been performed the divisor would have the exponent $2m$ so in the end the exponents
+do ``add up''. By using whole digits the algorithm is much faster since shifting digits is typically slower than simply copying them.  Using the 
+above equation the quotient $\lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ can be off from the true quotient by at most two implying that 
+$0 \le a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor < 3b$.  By first subtracting $b$ times the quotient and then conditionally 
+subtracting $b$ once or twice the residue is found.
+
+The quotient is now found using $(m + 1)(m) = m^2 + m$ single precision multiplications and the residue with an additional $m^2$ single
+precision multiplications.  In total $2m^2 + m$ single precision multiplications are required which is considerably faster than the original
+attempt.
+
+For example, let $\beta = 10$ represent the radix of the digits.  Let $b = 9999$ represent the modulus which implies $m = 4$. Let $a = 99929878$ 
+represent the value of which the residue is desired.  In this case $q = 10$ which means that $\mu = \lfloor \beta^{2m}/b \rfloor = 10001$.  
+With this optimization the multiplicand for the quotient is $q_0 = \lfloor a / \beta^{m - 1} \rfloor = 99929$.  The quotient is then 
+$\lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor = 9993$.  Subtracting $9993b$ from $a$ and the correct residue $9871 \equiv a \mbox{ (mod }b\mbox{)}$ 
+is found.  
+
+\subsection{Trimming the Quotient}
+So far the reduction algorithm has been optimized from $3m^2$ single precision multiplications down to $2m^2 + m$ single precision multiplications.  As 
+it stands now the algorithm is already fairly fast compared to a full integer division algorithm.  However, there is still room for
+optimization.  
+
+After the first multiplication inside the quotient ($q_0 \cdot \mu$) the value is shifted right by $m + 1$ places effectively nullifying the lower
+half of the product.  It would be nice to be able to remove those digits from the product to effectively cut down the number of multiplications.  
+If the number of digits in the modulus $m$ is far less than $\beta$ a full product is not required.  In fact the lower $m - 2$ digits will not
+affect the upper half of the product at all and do not need to be computed.  
+
+The value of $\mu$ is a $m$-digit number and $q_0$ is a $m + 1$ digit number.  Using a full multiplier $(m + 1)(m) = m^2 + m$ single precision
+multiplications would be required.  Using a multiplier that will only produce digits at and above the $m - 1$'th digit reduces the number
+of single precision multiplications to ${m^2 + m} \over 2$ single precision multiplications.  
+
+\subsection{Trimming the Residue}
+After the quotient has been calculated it is used to reduce the input.  As previously noted the algorithm is not exact and it can be off by a small
+multiple of the modulus, that is $0 \le a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor < 3b$.  If $b$ is $m$ digits than the 
+result of reduction equation is a value of at most $m + 1$ digits (\textit{provided $3 < \beta$}) implying that the upper $m - 1$ digits are
+implicitly zero.  
+
+The next optimization arises from this very fact.  Instead of computing $b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ using a full
+$O(m^2)$ multiplication algorithm only the lower $m+1$ digits of the product have to be computed.  Similarly the value of $a$ can
+be reduced modulo $\beta^{m+1}$ before the multiple of $b$ is subtracted which simplifes the subtraction as well.  A multiplication that produces 
+only the lower $m+1$ digits requires ${m^2 + 3m - 2} \over 2$ single precision multiplications.  
+
+With both optimizations in place the algorithm is the algorithm Barrett proposed.  It requires $m^2 + 2m - 1$ single precision multiplications which
+is considerably faster than the straightforward $3m^2$ method.  
+
+\subsection{The Barrett Algorithm}
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce}. \\
+\textbf{Input}.   mp\_int $a$, mp\_int $b$ and $\mu = \lfloor \beta^{2m}/b \rfloor$ $(0 \le a < b^2, b > 1)$ \\
+\textbf{Output}.  $c \leftarrow a \mbox{ (mod }b\mbox{)}$ \\
+\hline \\
+Let $m$ represent the number of digits in $b$.  \\
+1.  Make a copy of $a$ and store it in $q$.  (\textit{mp\_init\_copy}) \\
+2.  $q \leftarrow \lfloor q / \beta^{m - 1} \rfloor$ (\textit{mp\_rshd}) \\
+\\
+Produce the quotient. \\
+3.  $q \leftarrow q \cdot \mu$  (\textit{note: only produce digits at or above $m-1$}) \\
+4.  $q \leftarrow \lfloor q / \beta^{m + 1} \rfloor$ \\
+\\
+Subtract the multiple of modulus from the input. \\
+5.  $c \leftarrow a \mbox{ (mod }\beta^{m+1}\mbox{)}$ (\textit{mp\_mod\_2d}) \\
+6.  $q \leftarrow q \cdot b \mbox{ (mod }\beta^{m+1}\mbox{)}$ (\textit{s\_mp\_mul\_digs}) \\
+7.  $c \leftarrow c - q$ (\textit{mp\_sub}) \\
+\\
+Add $\beta^{m+1}$ if a carry occured. \\
+8.  If $c < 0$ then (\textit{mp\_cmp\_d}) \\
+\hspace{3mm}8.1  $q \leftarrow 1$ (\textit{mp\_set}) \\
+\hspace{3mm}8.2  $q \leftarrow q \cdot \beta^{m+1}$ (\textit{mp\_lshd}) \\
+\hspace{3mm}8.3  $c \leftarrow c + q$ \\
+\\
+Now subtract the modulus if the residue is too large (e.g. quotient too small). \\
+9.  While $c \ge b$ do (\textit{mp\_cmp}) \\
+\hspace{3mm}9.1  $c \leftarrow c - b$ \\
+10.  Clear $q$. \\
+11.  Return(\textit{MP\_OKAY}) \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce.}
+This algorithm will reduce the input $a$ modulo $b$ in place using the Barrett algorithm.  It is loosely based on algorithm 14.42 of 
+\cite[pp.  602]{HAC} which is based on \cite{BARRETT}.  The algorithm has several restrictions and assumptions which must be adhered to
+for the algorithm to work.
+
+First the modulus $b$ is assumed to be positive and greater than one.  If the modulus were less than or equal to one than subtracting
+a multiple of it would either accomplish nothing or actually enlarge the input.  The input $a$ must be in the range $0 \le a < b^2$ in order
+for the quotient to have enough precision.  Technically the algorithm will still work if $a \ge b^2$ but it will take much longer to finish.  The
+value of $\mu$ is passed as an argument to this algorithm and is assumed to be setup before the algorithm is used.  
+
+Recall that the multiplication for the quotient on step 3 must only produce digits at or above the $m-1$'th position.  An algorithm called 
+$s\_mp\_mul\_high\_digs$ which has not been presented is used to accomplish this task.  This optimal algorithm can only be used if the number
+of digits in $b$ is very much smaller than $\beta$.  
+
+After the multiple of the modulus has been subtracted from $a$ the residue must be fixed up in case its negative.  While it is known that 
+$a \ge b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ only the lower $m+1$ digits are being used to compute the residue.  In this case 
+the invariant $\beta^{m+1}$ must be added to the residue to make it positive again.  
+
+The while loop at step 9 will subtract $b$ until the residue is less than $b$.  If the algorithm is performed correctly this step is only
+performed upto two times.  However, if $a \ge b^2$ than it will iterate substantially more times than it should.
+
+\index{bn\_mp\_reduce.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* reduces x mod m, assumes 0 < x < m**2, mu is 
+018    * precomputed via mp_reduce_setup.
+019    * From HAC pp.604 Algorithm 14.42
+020    */
+021   int
+022   mp_reduce (mp_int * x, mp_int * m, mp_int * mu)
+023   \{
+024     mp_int  q;
+025     int     res, um = m->used;
+026   
+027     /* q = x */
+028     if ((res = mp_init_copy (&q, x)) != MP_OKAY) \{
+029       return res;
+030     \}
+031   
+032     /* q1 = x / b**(k-1)  */
+033     mp_rshd (&q, um - 1);         
+034   
+035     /* according to HAC this is optimization is ok */
+036     if (((unsigned long) m->used) > (((mp_digit)1) << (DIGIT_BIT - 1))) \{
+037       if ((res = mp_mul (&q, mu, &q)) != MP_OKAY) \{
+038         goto CLEANUP;
+039       \}
+040     \} else \{
+041       if ((res = s_mp_mul_high_digs (&q, mu, &q, um - 1)) != MP_OKAY) \{
+042         goto CLEANUP;
+043       \}
+044     \}
+045   
+046     /* q3 = q2 / b**(k+1) */
+047     mp_rshd (&q, um + 1);         
+048   
+049     /* x = x mod b**(k+1), quick (no division) */
+050     if ((res = mp_mod_2d (x, DIGIT_BIT * (um + 1), x)) != MP_OKAY) \{
+051       goto CLEANUP;
+052     \}
+053   
+054     /* q = q * m mod b**(k+1), quick (no division) */
+055     if ((res = s_mp_mul_digs (&q, m, &q, um + 1)) != MP_OKAY) \{
+056       goto CLEANUP;
+057     \}
+058   
+059     /* x = x - q */
+060     if ((res = mp_sub (x, &q, x)) != MP_OKAY) \{
+061       goto CLEANUP;
+062     \}
+063   
+064     /* If x < 0, add b**(k+1) to it */
+065     if (mp_cmp_d (x, 0) == MP_LT) \{
+066       mp_set (&q, 1);
+067       if ((res = mp_lshd (&q, um + 1)) != MP_OKAY)
+068         goto CLEANUP;
+069       if ((res = mp_add (x, &q, x)) != MP_OKAY)
+070         goto CLEANUP;
+071     \}
+072   
+073     /* Back off if it's too big */
+074     while (mp_cmp (x, m) != MP_LT) \{
+075       if ((res = s_mp_sub (x, m, x)) != MP_OKAY) \{
+076         break;
+077       \}
+078     \}
+079     
+080   CLEANUP:
+081     mp_clear (&q);
+082   
+083     return res;
+084   \}
+\end{alltt}
+\end{small}
+
+The first multiplication that determines the quotient can be performed by only producing the digits from $m - 1$ and up.  This essentially halves
+the number of single precision multiplications required.  However, the optimization is only safe if $\beta$ is much larger than the number of digits
+in the modulus.  In the source code this is evaluated on lines 36 to 44 where algorithm s\_mp\_mul\_high\_digs is used when it is
+safe to do so.  
+
+\subsection{The Barrett Setup Algorithm}
+In order to use algorithm mp\_reduce the value of $\mu$ must be calculated in advance.  Ideally this value should be computed once and stored for
+future use so that the Barrett algorithm can be used without delay.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce\_setup}. \\
+\textbf{Input}.   mp\_int $a$ ($a > 1$)  \\
+\textbf{Output}.  $\mu \leftarrow \lfloor \beta^{2m}/a \rfloor$ \\
+\hline \\
+1.  $\mu \leftarrow 2^{2 \cdot lg(\beta) \cdot  m}$ (\textit{mp\_2expt}) \\
+2.  $\mu \leftarrow \lfloor \mu / b \rfloor$ (\textit{mp\_div}) \\
+3.  Return(\textit{MP\_OKAY}) \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce\_setup}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce\_setup.}
+This algorithm computes the reciprocal $\mu$ required for Barrett reduction.  First $\beta^{2m}$ is calculated as $2^{2 \cdot lg(\beta) \cdot  m}$ which
+is equivalent and much faster.  The final value is computed by taking the integer quotient of $\lfloor \mu / b \rfloor$.
+
+\index{bn\_mp\_reduce\_setup.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_setup.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* pre-calculate the value required for Barrett reduction
+018    * For a given modulus "b" it calulates the value required in "a"
+019    */
+020   int
+021   mp_reduce_setup (mp_int * a, mp_int * b)
+022   \{
+023     int     res;
+024     
+025     if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) \{
+026       return res;
+027     \}
+028     return mp_div (a, b, a, NULL);
+029   \}
+\end{alltt}
+\end{small}
+
+This simple routine calculates the reciprocal $\mu$ required by Barrett reduction.  Note the extended usage of algorithm mp\_div where the variable
+which would received the remainder is passed as NULL.  As will be discussed in section 9.1 the division routine allows both the quotient and the 
+remainder to be passed as NULL meaning to ignore the value.  
+
+\section{The Montgomery Reduction}
+Montgomery reduction\footnote{Thanks to Niels Ferguson for his insightful explanation of the algorithm.} \cite{MONT} is by far the most interesting 
+form of reduction in common use.  It computes a modular residue which is not actually equal to the residue of the input yet instead equal to a 
+residue times a constant.  However, as perplexing as this may sound the algorithm is relatively simple and very efficient.  
+
+Throughout this entire section the variable $n$ will represent the modulus used to form the residue.  As will be discussed shortly the value of
+$n$ must be odd.  The variable $x$ will represent the quantity of which the residue is sought.  Similar to the Barrett algorithm the input
+is restricted to $0 \le x < n^2$.  To begin the description some simple number theory facts must be established.
+
+\textbf{Fact 1.}  Adding $n$ to $x$ does not change the residue since in effect it adds one to the quotient $\lfloor x / n \rfloor$.
+
+\textbf{Fact 2.}  If $x$ is even then performing a division by two in $\Z$ is congruent to $x \cdot 2^{-1} \mbox{ (mod }n\mbox{)}$.  For example,
+if $n = 7$ and $x = 6$ then $x/2 = 3$.  Using the modular inverse of two the same result is found.  That is, $2^{-1} \equiv (n+1)/2 \equiv 4$ and
+$4 \cdot 6 \equiv 3 \mbox{ (mod }n\mbox{)}$.  
+
+From these two simple facts the following simple algorithm can be derived.
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Montgomery Reduction}. \\
+\textbf{Input}.   Integer $x$, $n$ and $k$ \\
+\textbf{Output}.  $2^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  for $t$ from $1$ to $k$ do \\
+\hspace{3mm}1.1  If $x$ is odd then \\
+\hspace{6mm}1.1.1  $x \leftarrow x + n$ \\
+\hspace{3mm}1.2  $x \leftarrow x/2$ \\
+2.  Return $x$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Montgomery Reduction}
+\end{figure}
+
+The algorithm reduces the input one bit at a time using the two congruencies stated previously.  Inside the loop $n$, which is odd, is
+added to $x$ if $x$ is odd.  This forces $x$ to be even which allows the division by two in $\Z$ to be congruent to a modular division by two. 
+
+Let $r$ represent the final result of the Montgomery algorithm.  If $k > lg(n)$ and $0 \le x < n^2$ then the final result is limited to 
+$0 \le r < \lfloor x/2^k \rfloor + n$.  As a result at most a single subtraction is required to get the residue desired.
+
+Let $k = \lfloor lg(n) \rfloor + 1$ represent the number of bits in $n$.  The current algorithm requires $2k^2$ single precision shifts
+and $k^2$ single precision additions.  At this rate the algorithm is most certainly slower than Barrett reduction and not terribly useful.  
+Fortunately there exists an alternative representation of the algorithm.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Montgomery Reduction} (modified I). \\
+\textbf{Input}.   Integer $x$, $n$ and $k$ \\
+\textbf{Output}.  $2^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  for $t$ from $0$ to $k - 1$ do \\
+\hspace{3mm}1.1  If the $t$'th bit of $x$ is one then \\
+\hspace{6mm}1.1.1  $x \leftarrow x + 2^tn$ \\
+2.  Return $x/2^k$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Montgomery Reduction (modified I)}
+\end{figure}
+
+This algorithm is equivalent since $2^tn$ is a multiple of $n$ and the lower $k$ bits of $x$ are zero by step 2.  The number of single
+precision shifts has now been reduced from $2k^2$ to $k^2 + 1$ which is only a small improvement.
+
+\subsection{Digit Based Montgomery Reduction}
+Instead of computing the reduction on a bit-by-bit basis it is actually much faster to compute it on digit-by-digit basis.  Consider the
+previous algorithm re-written to compute the Montgomery reduction in this new fashion.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Montgomery Reduction} (modified II). \\
+\textbf{Input}.   Integer $x$, $n$ and $k$ \\
+\textbf{Output}.  $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  for $t$ from $0$ to $k - 1$ do \\
+\hspace{3mm}1.1  $x \leftarrow x + \mu n \beta^t$ \\
+2.  Return $x/\beta^k$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Montgomery Reduction (modified II)}
+\end{figure}
+
+The value $\mu n \beta^t$ is a multiple of the modulus $n$ meaning that it will not change the residue.  If the first digit of 
+the value $\mu n \beta^t$ equals the negative (modulo $\beta$) of the $t$'th digit of $x$ then the addition will result in a zero digit.  This
+problem breaks down to solving the following congruency.  
+
+\begin{center}
+\begin{tabular}{rcl}
+$x_t + \mu n_0$ & $\equiv$ & $0 \mbox{ (mod }\beta\mbox{)}$ \\
+$\mu n_0$ & $\equiv$ & $-x_t \mbox{ (mod }\beta\mbox{)}$ \\
+$\mu$ & $\equiv$ & $-x_t/n_0 \mbox{ (mod }\beta\mbox{)}$ \\
+\end{tabular}
+\end{center}
+
+In each iteration of the loop on step 1 a new value of $\mu$ must be calculated.  The value of $-1/n_0 \mbox{ (mod }\beta\mbox{)}$ is used 
+extensively in this algorithm and should be precomputed.  Let $\rho$ represent the negative of the modular inverse of $n_0$ modulo $\beta$.  
+
+For example, let $\beta = 10$ represent the radix.  Let $n = 17$ represent the modulus which implies $k = 2$ and $\rho \equiv 7$.  Let $x = 33$ 
+represent the value to reduce.
+
+\newpage\begin{figure}
+\begin{center}
+\begin{tabular}{|c|c|c|}
+\hline \textbf{Step ($t$)} & \textbf{Value of $x$} & \textbf{Value of $\mu$} \\
+\hline --                 & $33$ & --\\
+\hline $0$                 & $33 + \mu n = 50$ & $1$ \\
+\hline $1$                 & $50 + \mu n \beta = 900$ & $5$ \\
+\hline
+\end{tabular}
+\end{center}
+\caption{Example of Montgomery Reduction}
+\end{figure}
+
+The final result $900$ is then divided by $\beta^k$ to produce the final result $9$.  The first observation is that $9 \nequiv x \mbox{ (mod }n\mbox{)}$ 
+which implies the result is not the modular residue of $x$ modulo $n$.  However, recall that the residue is actually multiplied by $\beta^{-k}$ in
+the algorithm.  To get the true residue the value must be multiplied by $\beta^k$.  In this case $\beta^k \equiv 15 \mbox{ (mod }n\mbox{)}$ and
+the correct residue is $9 \cdot 15 \equiv 16 \mbox{ (mod }n\mbox{)}$.  
+
+\subsection{Baseline Montgomery Reduction}
+The baseline Montgomery reduction algorithm will produce the residue for any size input.  It is designed to be a catch-all algororithm for 
+Montgomery reductions.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_montgomery\_reduce}. \\
+\textbf{Input}.   mp\_int $x$, mp\_int $n$ and a digit $\rho \equiv -1/n_0 \mbox{ (mod }n\mbox{)}$. \\
+\hspace{11.5mm}($0 \le x < n^2, n > 1, (n, \beta) = 1, \beta^k > n$) \\
+\textbf{Output}.  $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+1.  $digs \leftarrow 2n.used + 1$ \\
+2.  If $digs < MP\_ARRAY$ and $m.used < \delta$ then \\
+\hspace{3mm}2.1  Use algorithm fast\_mp\_montgomery\_reduce instead. \\
+\\
+Setup $x$ for the reduction. \\
+3.  If $x.alloc < digs$ then grow $x$ to $digs$ digits. \\
+4.  $x.used \leftarrow digs$ \\
+\\
+Eliminate the lower $k$ digits. \\
+5.  For $ix$ from $0$ to $k - 1$ do \\
+\hspace{3mm}5.1  $\mu \leftarrow x_{ix} \cdot \rho \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}5.2  $u \leftarrow 0$ \\
+\hspace{3mm}5.3  For $iy$ from $0$ to $k - 1$ do \\
+\hspace{6mm}5.3.1  $\hat r \leftarrow \mu n_{iy} + x_{ix + iy} + u$ \\
+\hspace{6mm}5.3.2  $x_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{6mm}5.3.3  $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+\hspace{3mm}5.4  While $u > 0$ do \\
+\hspace{6mm}5.4.1  $iy \leftarrow iy + 1$ \\
+\hspace{6mm}5.4.2  $x_{ix + iy} \leftarrow x_{ix + iy} + u$ \\
+\hspace{6mm}5.4.3  $u \leftarrow \lfloor x_{ix+iy} / \beta \rfloor$ \\
+\hspace{6mm}5.4.4  $x_{ix + iy} \leftarrow x_{ix+iy} \mbox{ (mod }\beta\mbox{)}$ \\
+\\
+Divide by $\beta^k$ and fix up as required. \\
+6.  $x \leftarrow \lfloor x / \beta^k \rfloor$ \\
+7.  If $x \ge n$ then \\
+\hspace{3mm}7.1  $x \leftarrow x - n$ \\
+8.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_montgomery\_reduce}
+\end{figure}
+
+\textbf{Algorithm mp\_montgomery\_reduce.}
+This algorithm reduces the input $x$ modulo $n$ in place using the Montgomery reduction algorithm.  The algorithm is loosely based
+on algorithm 14.32 of \cite[pp.601]{HAC} except it merges the multiplication of $\mu n \beta^t$ with the addition in the inner loop.  The
+restrictions on this algorithm are fairly easy to adapt to.  First $0 \le x < n^2$ bounds the input to numbers in the same range as 
+for the Barrett algorithm.  Additionally $n > 1$ will ensure a modular inverse $\rho$ exists.  $\rho$ must be calculated in
+advance of this algorithm.  Finally the variable $k$ is fixed and a pseudonym for $n.used$.  
+
+Step 2 decides whether a faster Montgomery algorithm can be used.  It is based on the Comba technique meaning that there are limits on
+the size of the input.  This algorithm is discussed in sub-section 7.3.3.
+
+Step 5 is the main reduction loop of the algorithm.  The value of $\mu$ is calculated once per iteration in the outer loop.  The inner loop
+calculates $x + \mu n \beta^{ix}$ by multiplying $\mu n$ and adding the result to $x$ shifted by $ix$ digits.  Both the addition and
+multiplication are performed in the same loop to save time and memory.  Step 5.4 will handle any additional carries that escape the inner loop.
+
+Using a quick inspection this algorithm requires $n$ single precision multiplications for the outer loop and $n^2$ single precision multiplications 
+in the inner loop.  In total $n^2 + n$ single precision multiplications which compares favourably to Barrett at $n^2 + 2n - 1$ single precision
+multiplications.  
+
+\index{bn\_mp\_montgomery\_reduce.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_montgomery\_reduce.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* computes xR**-1 == x (mod N) via Montgomery Reduction */
+018   int
+019   mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
+020   \{
+021     int     ix, res, digs;
+022     mp_digit mu;
+023   
+024     /* can the fast reduction [comba] method be used?
+025      *
+026      * Note that unlike in mp_mul you're safely allowed *less*
+027      * than the available columns [255 per default] since carries
+028      * are fixed up in the inner loop.
+029      */
+030     digs = n->used * 2 + 1;
+031     if ((digs < MP_WARRAY) && 
+032         n->used < 
+033         (1 << ((CHAR_BIT * sizeof (mp_word)) - (2 * DIGIT_BIT)))) \{
+034       return fast_mp_montgomery_reduce (x, n, rho);
+035     \}
+036   
+037     /* grow the input as required */
+038     if (x->alloc < digs) \{
+039       if ((res = mp_grow (x, digs)) != MP_OKAY) \{
+040         return res;
+041       \}
+042     \}
+043     x->used = digs;
+044   
+045     for (ix = 0; ix < n->used; ix++) \{
+046       /* mu = ai * m' mod b */
+047       mu = (x->dp[ix] * rho) & MP_MASK;
+048   
+049       /* a = a + mu * m * b**i */
+050       \{
+051         register int iy;
+052         register mp_digit *tmpn, *tmpx, u;
+053         register mp_word r;
+054   
+055         /* aliases */
+056         tmpn = n->dp;
+057         tmpx = x->dp + ix;
+058   
+059         /* set the carry to zero */
+060         u = 0;
+061         
+062         /* Multiply and add in place */
+063         for (iy = 0; iy < n->used; iy++) \{
+064           r = ((mp_word) mu) * ((mp_word) * tmpn++) + 
+065               ((mp_word) u) + ((mp_word) * tmpx);
+066           u = (r >> ((mp_word) DIGIT_BIT));
+067           *tmpx++ = (r & ((mp_word) MP_MASK));
+068         \}
+069         /* propagate carries */
+070         while (u) \{
+071           *tmpx += u;
+072           u = *tmpx >> DIGIT_BIT;
+073           *tmpx++ &= MP_MASK;
+074         \}
+075       \}
+076     \}
+077   
+078     /* x = x/b**n.used */
+079     mp_rshd (x, n->used);
+080   
+081     /* if A >= m then A = A - m */
+082     if (mp_cmp_mag (x, n) != MP_LT) \{
+083       return s_mp_sub (x, n, x);
+084     \}
+085   
+086     return MP_OKAY;
+087   \}
+\end{alltt}
+\end{small}
+
+This is the baseline implementation of the Montgomery reduction algorithm.  Lines 30 to 35 determine if the Comba based
+routine can be used instead.  Line 47 computes the value of $\mu$ for that particular iteration of the outer loop.  
+
+The multiplication $\mu n \beta^{ix}$ is performed in one step in the inner loop.  The alias $tmpx$ refers to the $ix$'th digit of $x$ and
+the alias $tmpn$ refers to the modulus $n$.  
+
+\subsection{Faster ``Comba'' Montgomery Reduction}
+
+The Montgomery reduction requires fewer single precision multiplications than a Barrett reduction, however it is much slower due to the serial
+nature of the inner loop.  The Barrett reduction algorithm requires two slightly modified multipliers which can be implemented with the Comba
+technique.  The Montgomery reduction algorithm cannot directly use the Comba technique to any significant advantage since the inner loop calculates
+a $k \times 1$ product $k$ times. 
+
+The biggest obstacle is that at the $ix$'th iteration of the outer loop the value of $x_{ix}$ is required to calculate $\mu$.  This means the 
+carries from $0$ to $ix - 1$ must have been propagated upwards to form a valid $ix$'th digit.  The solution as it turns out is very simple.  
+Perform a Comba like multiplier and inside the outer loop just after the inner loop fix up the $ix + 1$'th digit by forwarding the carry.  
+
+With this change in place the Montgomery reduction algorithm can be performed with a Comba style multiplication loop which substantially increases
+the speed of the algorithm.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{fast\_mp\_montgomery\_reduce}. \\
+\textbf{Input}.   mp\_int $x$, mp\_int $n$ and a digit $\rho \equiv -1/n_0 \mbox{ (mod }n\mbox{)}$. \\
+\hspace{11.5mm}($0 \le x < n^2, n > 1, (n, \beta) = 1, \beta^k > n$) \\
+\textbf{Output}.  $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\
+\hline \\
+Place an array of \textbf{MP\_WARRAY} mp\_word variables called $\hat W$ on the stack. \\
+1.  if $x.alloc < n.used + 1$ then grow $x$ to $n.used + 1$ digits. \\
+Copy the digits of $x$ into the array $\hat W$ \\
+2.  For $ix$ from $0$ to $x.used - 1$ do \\
+\hspace{3mm}2.1  $\hat W_{ix} \leftarrow x_{ix}$ \\
+3.  For $ix$ from $x.used$ to $2n.used - 1$ do \\
+\hspace{3mm}3.1  $\hat W_{ix} \leftarrow 0$ \\
+Elimiate the lower $k$ digits. \\
+4.  for $ix$ from $0$ to $n.used - 1$ do \\
+\hspace{3mm}4.1  $\mu \leftarrow \hat W_{ix} \cdot \rho \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}4.2  For $iy$ from $0$ to $n.used - 1$ do \\
+\hspace{6mm}4.2.1  $\hat W_{iy + ix} \leftarrow \hat W_{iy + ix} + \mu \cdot n_{iy}$ \\
+\hspace{3mm}4.3  $\hat W_{ix + 1} \leftarrow \hat W_{ix + 1} + \lfloor \hat W_{ix} / \beta \rfloor$ \\
+Propagate carries upwards. \\
+5.  for $ix$ from $n.used$ to $2n.used + 1$ do \\
+\hspace{3mm}5.1  $\hat W_{ix + 1} \leftarrow \hat W_{ix + 1} + \lfloor \hat W_{ix} / \beta \rfloor$ \\
+Shift right and reduce modulo $\beta$ simultaneously. \\
+6.  for $ix$ from $0$ to $n.used + 1$ do \\
+\hspace{3mm}6.1  $x_{ix} \leftarrow \hat W_{ix + n.used} \mbox{ (mod }\beta\mbox{)}$ \\
+Zero excess digits and fixup $x$. \\
+7.  if $x.used > n.used + 1$ then do \\
+\hspace{3mm}7.1  for $ix$ from $n.used + 1$ to $x.used - 1$ do \\
+\hspace{6mm}7.1.1  $x_{ix} \leftarrow 0$ \\
+8.  $x.used \leftarrow n.used + 1$ \\
+9.  Clamp excessive digits of $x$. \\
+10.  If $x \ge n$ then \\
+\hspace{3mm}10.1  $x \leftarrow x - n$ \\
+11.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm fast\_mp\_montgomery\_reduce}
+\end{figure}
+
+\textbf{Algorithm fast\_mp\_montgomery\_reduce.}
+This algorithm will compute the Montgomery reduction of $x$ modulo $n$ using the Comba technique.  It is on most computer platforms significantly
+faster than algorithm mp\_montgomery\_reduce and algorithm mp\_reduce (\textit{Barrett reduction}).  The algorithm has the same restrictions
+on the input as the baseline reduction algorithm.  An additional two restrictions are imposed on this algorithm.  The number of digits $k$ in the 
+the modulus $n$ must not violate $MP\_WARRAY > 2k +1$ and $n < \delta$.   When $\beta = 2^{28}$ this algorithm can be used to reduce modulo
+a modulus of at most $3,556$ bits in length.  
+
+As in the other Comba reduction algorithms there is a $\hat W$ array which stores the columns of the product.  It is initially filled with the
+contents of $x$ with the excess digits zeroed.  The reduction loop is very similar the to the baseline loop at heart.  The multiplication on step
+4.1 can be single precision only since $ab \mbox{ (mod }\beta\mbox{)} \equiv (a \mbox{ mod }\beta)(b \mbox{ mod }\beta)$.  Some multipliers such
+as those on the ARM processors take a variable length time to complete depending on the number of bytes of result it must produce.  By performing
+a single precision multiplication instead half the amount of time is spent.
+
+Also note that digit $\hat W_{ix}$ must have the carry from the $ix - 1$'th digit propagated upwards in order for this to work.  That is what step
+4.3 will do.  In effect over the $n.used$ iterations of the outer loop the $n.used$'th lower columns all have the their carries propagated forwards.  Note
+how the upper bits of those same words are not reduced modulo $\beta$.  This is because those values will be discarded shortly and there is no
+point.
+
+Step 5 will propgate the remainder of the carries upwards.  On step 6 the columns are reduced modulo $\beta$ and shifted simultaneously as they are
+stored in the destination $x$.  
+
+\index{bn\_fast\_mp\_montgomery\_reduce.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_fast\_mp\_montgomery\_reduce.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* computes xR**-1 == x (mod N) via Montgomery Reduction 
+018    * 
+019    * This is an optimized implementation of mp_montgomery_reduce 
+020    * which uses the comba method to quickly calculate the columns of the
+021    * reduction.  
+022    *
+023    * Based on Algorithm 14.32 on pp.601 of HAC.
+024   */
+025   int
+026   fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho)
+027   \{
+028     int     ix, res, olduse;
+029     mp_word W[MP_WARRAY];
+030   
+031     /* get old used count */
+032     olduse = x->used;
+033   
+034     /* grow a as required */
+035     if (x->alloc < n->used + 1) \{
+036       if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) \{
+037         return res;
+038       \}
+039     \}
+040   
+041     \{
+042       register mp_word *_W;
+043       register mp_digit *tmpx;
+044   
+045       _W = W;
+046       tmpx = x->dp;
+047   
+048       /* copy the digits of a into W[0..a->used-1] */
+049       for (ix = 0; ix < x->used; ix++) \{
+050         *_W++ = *tmpx++;
+051       \}
+052   
+053       /* zero the high words of W[a->used..m->used*2] */
+054       for (; ix < n->used * 2 + 1; ix++) \{
+055         *_W++ = 0;
+056       \}
+057     \}
+058   
+059     for (ix = 0; ix < n->used; ix++) \{
+060       /* mu = ai * m' mod b
+061        *
+062        * We avoid a double precision multiplication (which isn't required)
+063        * by casting the value down to a mp_digit.  Note this requires 
+064        * that W[ix-1] have  the carry cleared (see after the inner loop)
+065        */
+066       register mp_digit mu;
+067       mu = (((mp_digit) (W[ix] & MP_MASK)) * rho) & MP_MASK;
+068   
+069       /* a = a + mu * m * b**i
+070        *
+071        * This is computed in place and on the fly.  The multiplication
+072        * by b**i is handled by offseting which columns the results
+073        * are added to.
+074        *
+075        * Note the comba method normally doesn't handle carries in the 
+076        * inner loop In this case we fix the carry from the previous 
+077        * column since the Montgomery reduction requires digits of the 
+078        * result (so far) [see above] to work.  This is
+079        * handled by fixing up one carry after the inner loop.  The 
+080        * carry fixups are done in order so after these loops the 
+081        * first m->used words of W[] have the carries fixed
+082        */
+083       \{
+084         register int iy;
+085         register mp_digit *tmpn;
+086         register mp_word *_W;
+087   
+088         /* alias for the digits of the modulus */
+089         tmpn = n->dp;
+090   
+091         /* Alias for the columns set by an offset of ix */
+092         _W = W + ix;
+093   
+094         /* inner loop */
+095         for (iy = 0; iy < n->used; iy++) \{
+096             *_W++ += ((mp_word) mu) * ((mp_word) * tmpn++);
+097         \}
+098       \}
+099   
+100       /* now fix carry for next digit, W[ix+1] */
+101       W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT);
+102     \}
+103   
+104   
+105     \{
+106       register mp_digit *tmpx;
+107       register mp_word *_W, *_W1;
+108   
+109       /* nox fix rest of carries */
+110       _W1 = W + ix;
+111       _W = W + ++ix;
+112   
+113       for (; ix <= n->used * 2 + 1; ix++) \{
+114         *_W++ += *_W1++ >> ((mp_word) DIGIT_BIT);
+115       \}
+116   
+117       /* copy out, A = A/b**n
+118        *
+119        * The result is A/b**n but instead of converting from an 
+120        * array of mp_word to mp_digit than calling mp_rshd 
+121        * we just copy them in the right order
+122        */
+123       tmpx = x->dp;
+124       _W = W + n->used;
+125   
+126       for (ix = 0; ix < n->used + 1; ix++) \{
+127         *tmpx++ = *_W++ & ((mp_word) MP_MASK);
+128       \}
+129   
+130       /* zero oldused digits, if the input a was larger than
+131        * m->used+1 we'll have to clear the digits */
+132       for (; ix < olduse; ix++) \{
+133         *tmpx++ = 0;
+134       \}
+135     \}
+136   
+137     /* set the max used and clamp */
+138     x->used = n->used + 1;
+139     mp_clamp (x);
+140   
+141     /* if A >= m then A = A - m */
+142     if (mp_cmp_mag (x, n) != MP_LT) \{
+143       return s_mp_sub (x, n, x);
+144     \}
+145     return MP_OKAY;
+146   \}
+\end{alltt}
+\end{small}
+
+The $\hat W$ array is first filled with digits of $x$ on line 49 then the rest of the digits are zeroed on line 54.  Both loops share
+the same alias variables to make the code easier to read.  
+
+The value of $\mu$ is calculated in an interesting fashion.  First the value $\hat W_{ix}$ is reduced modulo $\beta$ and cast to a mp\_digit.  This
+forces the compiler to use a single precision multiplication and prevents any concerns about loss of precision.   Line 101 fixes the carry 
+for the next iteration of the loop by propagating the carry from $\hat W_{ix}$ to $\hat W_{ix+1}$.
+
+The for loop on line 113 propagates the rest of the carries upwards through the columns.  The for loop on line 126 reduces the columns
+modulo $\beta$ and shifts them $k$ places at the same time.  The alias $\_ \hat W$ actually refers to the array $\hat W$ starting at the $n.used$'th
+digit, that is $\_ \hat W_{t} = \hat W_{n.used + t}$.  
+
+\subsection{Montgomery Setup}
+To calculate the variable $\rho$ a relatively simple algorithm will be required.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_montgomery\_setup}. \\
+\textbf{Input}.   mp\_int $n$ ($n > 1$ and $(n, 2) = 1$) \\
+\textbf{Output}.  $\rho \equiv -1/n_0 \mbox{ (mod }\beta\mbox{)}$ \\
+\hline \\
+1.  $b \leftarrow n_0$ \\
+2.  If $b$ is even return(\textit{MP\_VAL}) \\
+3.  $x \leftarrow ((b + 2) \mbox{ AND } 4) << 1) + b$ \\
+4.  for $k$ from 0 to $3$ do \\
+\hspace{3mm}4.1  $x \leftarrow x \cdot (2 - bx)$ \\
+5.  $\rho \leftarrow \beta - x \mbox{ (mod }\beta\mbox{)}$ \\
+6.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_montgomery\_setup} 
+\end{figure}
+
+\textbf{Algorithm mp\_montgomery\_setup.}
+This algorithm will calculate the value of $\rho$ required within the Montgomery reduction algorithms.  It uses a very interesting trick 
+to calculate $1/n_0$ when $\beta$ is a power of two.  
+
+\index{bn\_mp\_montgomery\_setup.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_montgomery\_setup.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* setups the montgomery reduction stuff */
+018   int
+019   mp_montgomery_setup (mp_int * n, mp_digit * rho)
+020   \{
+021     mp_digit x, b;
+022   
+023   /* fast inversion mod 2**k
+024    *
+025    * Based on the fact that
+026    *
+027    * XA = 1 (mod 2**n)  =>  (X(2-XA)) A = 1 (mod 2**2n)
+028    *                    =>  2*X*A - X*X*A*A = 1
+029    *                    =>  2*(1) - (1)     = 1
+030    */
+031     b = n->dp[0];
+032   
+033     if ((b & 1) == 0) \{
+034       return MP_VAL;
+035     \}
+036   
+037     x = (((b + 2) & 4) << 1) + b; /* here x*a==1 mod 2**4 */
+038     x *= 2 - b * x;               /* here x*a==1 mod 2**8 */
+039   #if !defined(MP_8BIT)
+040     x *= 2 - b * x;               /* here x*a==1 mod 2**16 */
+041   #endif
+042   #if defined(MP_64BIT) || !(defined(MP_8BIT) || defined(MP_16BIT))
+043     x *= 2 - b * x;               /* here x*a==1 mod 2**32 */
+044   #endif
+045   #ifdef MP_64BIT
+046     x *= 2 - b * x;               /* here x*a==1 mod 2**64 */
+047   #endif
+048   
+049     /* rho = -1/m mod b */
+050     *rho = (((mp_digit) 1 << ((mp_digit) DIGIT_BIT)) - x) & MP_MASK;
+051   
+052     return MP_OKAY;
+053   \}
+\end{alltt}
+\end{small}
+
+This source code computes the value of $\rho$ required to perform Montgomery reduction.  It has been modified to avoid performing excess
+multiplications when $\beta$ is not the default 28-bits.  
+
+\section{The Diminished Radix Algorithm}
+The diminished radix method of modular reduction \cite{DRMET} is a fairly clever technique which is more efficient than either the Barrett
+or Montgomery methods.  The technique is based on a simple congruence.
+
+\begin{equation}
+(x \mbox{ mod } n) + k \lfloor x / n \rfloor \equiv x \mbox{ (mod }(n - k)\mbox{)}
+\end{equation}
+
+This observation was used in the MMB \cite{MMB} block cipher to create a diffusion primitive.  It used the fact that if $n = 2^{31}$ and $k=1$ that 
+then a x86 multiplier could produce the 62-bit product and use  the ``shrd'' instruction to perform a double-precision right shift.  The proof
+of the above equation is very simple.  First write $x$ in the product form.
+
+\begin{equation}
+x = qn + r
+\end{equation}
+
+Now reduce both sides modulo $(n - k)$.
+
+\begin{equation}
+x \equiv qk + r  \mbox{ (mod }(n-k)\mbox{)}
+\end{equation}
+
+The variable $n$ reduces as $n \mbox{ mod } (n - k)$ to $k$.  By putting $q = \lfloor x/n \rfloor$ and $r = x \mbox{ mod } n$ 
+into the equation the original congruence is reproduced.  The following algorithm is based on these observations.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Diminished Radix Reduction}. \\
+\textbf{Input}.   Integer $x$, $n$, $k$ \\
+\textbf{Output}.  $x \mbox{ mod } (n - k)$ \\
+\hline \\
+1.  $q \leftarrow \lfloor x / n \rfloor$ \\
+2.  $q \leftarrow k \cdot q$ \\
+3.  $x \leftarrow x \mbox{ (mod }n\mbox{)}$ \\
+4.  $x \leftarrow x + q$ \\
+5.  If $x \ge (n - k)$ then \\
+\hspace{3mm}5.1  $x \leftarrow x - (n - k)$ \\
+\hspace{3mm}5.2  Goto step 1. \\
+6.  Return $x$ \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm Diminished Radix Reduction}
+\label{fig:DR}
+\end{figure}
+
+This algorithm will reduce $x$ modulo $n - k$ and return the residue.  If $0 \le x < (n - k)^2$ then the algorithm will loop almost always
+once or twice and occasionally three times.  For simplicity sake the value of $x$ is bounded by the following simple polynomial.
+
+\begin{equation} 
+0 \le x < n^2 + k^2 - 2nk
+\end{equation}
+
+The true bound is  $0 \le x < (n - k - 1)^2$ but this has quite a few more terms.  The value of $q$ after step 1 is bounded by the following.
+
+\begin{equation}
+q < n - 2k - k^2/n
+\end{equation}
+
+Since $k^2$ is going to be considerably smaller than $n$ that term will always be zero.  The value of $x$ after step 3 is bounded trivially as
+$0 \le x < n$.  By step four the sum $x + q$ is bounded by 
+
+\begin{equation}
+0 \le q + x < (k + 1)n - 2k^2 - 1
+\end{equation}
+
+As a result at most $k$ subtractions of $n$ are required to produce the residue.  With a second pass $q$ will be loosely bounded by $0 \le q < k^2$
+after step 2 while $x$ will still be loosely bounded by $0 \le x < n$ after step 3.  After the second pass it is highly unlike that the
+sum in step 4 will exceed $n - k$.  In practice fewer than three passes of the algorithm are required to reduce virtually every input in the 
+range $0 \le x < (n - k - 1)^2$.  
+
+\subsection{Choice of Moduli}
+On the surface this algorithm looks like a very expensive algorithm.  It requires a couple of subtractions followed by multiplication and other
+modular reductions.  The usefulness of this algorithm becomes exceedingly clear when an appropriate moduli is chosen.
+
+Division in general is a very expensive operation to perform.  The one exception is when the division is by a power of the radix of representation used.  
+Division by ten for example is simple for humans since it amounts to shifting the decimal place.  Similarly division by two 
+(\textit{or powers of two}) is very simple for computers to perform.  It would therefore seem logical to choose $n$ of the form $2^p$ 
+which would imply that $\lfloor x / n \rfloor$ is a simple shift of $x$ right $p$ bits.  
+
+However, there is one operation related to division of power of twos that is even faster than this.  If $n = \beta^p$ then the division may be 
+performed by moving whole digits to the right $p$ places.  In practice division by $\beta^p$ is much faster than division by $2^p$ for any $p$.  
+Also with the choice of $n = \beta^p$ reducing $x$ modulo $n$ requires zeroing the digits above the $p-1$'th digit of $x$.  
+
+Throughout the next section the term ``restricted modulus'' will refer to a modulus of the form $\beta^p - k$ where as the term ``unrestricted
+modulus'' will refer to a modulus of the form $2^p - k$.  The word ``restricted'' in this case refers to the fact that it is based on the 
+$2^p$ logic except $p$ must be a multiple of $lg(\beta)$.  
+
+\subsection{Choice of $k$}
+Now that division and reduction (\textit{step 1 and 3 of figure~\ref{fig:DR}}) have been optimized to simple digit operations the multiplication by $k$
+in step 2 is the most expensive operation.  Fortunately the choice of $k$ is not terribly limited.  For all intents and purposes it might
+as well be a single digit.  
+
+\subsection{Restricted Diminished Radix Reduction}
+The restricted Diminished Radix algorithm can quickly reduce numbers modulo numbers of the form $n = \beta^p - k$.  This algorithm can reduce 
+an input $x$ within the range $0 \le x < n^2$ using a couple passes of the algorithm demonstrated in figure~\ref{fig:DR}.  The implementation
+of this algorithm has been optimized to avoid additional overhead associated with a division by $\beta^p$, the
+multiplication by $k$ or the addition of $x$ and $q$.  The resulting algorithm is very efficient and can lead to substantial improvements when
+modular exponentiations are performed compared to Montgomery based reduction algorithms.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_dr\_reduce}. \\
+\textbf{Input}.   mp\_int $x$, $n$ and a mp\_digit $k = \beta - n_0$ \\
+\hspace{11.5mm}($0 \le x < n^2$, $n > 1$, $0 < k \le \beta$) \\
+\textbf{Output}.  $x \mbox{ mod } n$ \\
+\hline \\
+1.  $m \leftarrow n.used$ \\
+2.  If $x.alloc < 2m$ then grow $x$ to $2m$ digits. \\
+3.  $\mu \leftarrow 0$ \\
+4.  for $i$ from $0$ to $m - 1$ do \\
+\hspace{3mm}4.1  $\hat r \leftarrow k \cdot x_{m+i} + x_{i} + \mu$ \\
+\hspace{3mm}4.2  $x_{i} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\
+\hspace{3mm}4.3  $\mu \leftarrow \lfloor \hat r / \beta \rfloor$ \\
+5.  $x_{m} \leftarrow \mu$ \\
+6.  for $i$ from $m + 1$ to $x.used - 1$ do \\
+\hspace{3mm}6.1  $x_{i} \leftarrow 0$ \\
+7.  Clamp excess digits of $x$. \\
+8.  If $x \ge n$ then \\
+\hspace{3mm}8.1  $x \leftarrow x - n$ \\
+\hspace{3mm}8.2  Goto step 3. \\
+9.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_dr\_reduce}
+\end{figure}
+
+\textbf{Algorithm mp\_dr\_reduce.}
+This algorithm will perform the dimished radix reduction of $x$ modulo $n$.  It has similar restrictions to that of the Barrett reduction
+with the addition that $n$ must be of the form $n = \beta^m - k$ where $0 < k \le \beta$.  
+
+This algorithm essentially implements the pseudo-code in figure 7.10 except with a slight optimization.  The division by $\beta^m$, multiplication by $k$
+and addition of $x \mbox{ mod }\beta^m$ are all performed as one step inside the loop on step 4.  The division by $\beta^m$ is emulated by accessing
+the term at the $m+i$'th position which is subsequently multiplied by $k$ and added to the term at the $i$'th position.  After the loop the $m$'th
+digit is set to the carry and the upper digits are zeroed.  Step 5 and 6 emulate the reduction modulo $\beta^m$ that should have happend to 
+$x$ before the addition of the multiple of the upper half.  
+
+At step 8 if $x$ is still larger than $n$ another pass of the algorithm is required.  First $n$ is subtracted from $x$ and then the algorithm resumes
+at step 3.  
+
+\index{bn\_mp\_dr\_reduce.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_reduce.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* reduce "x" in place modulo "n" using the Diminished Radix algorithm.
+018    *
+019    * Based on algorithm from the paper
+020    *
+021    * "Generating Efficient Primes for Discrete Log Cryptosystems"
+022    *                 Chae Hoon Lim, Pil Loong Lee,
+023    *          POSTECH Information Research Laboratories
+024    *
+025    * The modulus must be of a special format [see manual]
+026    *
+027    * Has been modified to use algorithm 7.10 from the LTM book instead
+028    */
+029   int
+030   mp_dr_reduce (mp_int * x, mp_int * n, mp_digit k)
+031   \{
+032     int      err, i, m;
+033     mp_word  r;
+034     mp_digit mu, *tmpx1, *tmpx2;
+035     
+036     /* m = digits in modulus */
+037     m = n->used;
+038     
+039     /* ensure that "x" has at least 2m digits */
+040     if (x->alloc < m + m) \{
+041       if ((err = mp_grow (x, m + m)) != MP_OKAY) \{
+042         return err;
+043       \}
+044     \}
+045   
+046   /* top of loop, this is where the code resumes if 
+047    * another reduction pass is required.
+048    */
+049   top:
+050     /* aliases for digits */
+051     /* alias for lower half of x */
+052     tmpx1 = x->dp;
+053     
+054     /* alias for upper half of x, or x/B**m */
+055     tmpx2 = x->dp + m;
+056     
+057     /* set carry to zero */
+058     mu = 0;
+059     
+060     /* compute (x mod B**m) + mp * [x/B**m] inline and inplace */
+061     for (i = 0; i < m; i++) \{
+062         r         = ((mp_word)*tmpx2++) * ((mp_word)k) + *tmpx1 + mu;
+063         *tmpx1++  = r & MP_MASK;
+064         mu        = r >> ((mp_word)DIGIT_BIT);
+065     \}
+066     
+067     /* set final carry */
+068     *tmpx1++ = mu;
+069     
+070     /* zero words above m */
+071     for (i = m + 1; i < x->used; i++) \{
+072         *tmpx1++ = 0;
+073     \}
+074   
+075     /* clamp, sub and return */
+076     mp_clamp (x);
+077   
+078     /* if x >= n then subtract and reduce again 
+079      * Each successive "recursion" makes the input smaller and smaller.
+080      */
+081     if (mp_cmp_mag (x, n) != MP_LT) \{
+082       s_mp_sub(x, n, x);
+083       goto top;
+084     \}
+085     return MP_OKAY;
+086   \}
+\end{alltt}
+\end{small}
+
+The first step is to grow $x$ as required to $2m$ digits since the reduction is performed in place on $x$.  The label on line 49 is where
+the algorithm will resume if further reduction passes are required.  In theory it could be placed at the top of the function however, the size of
+the modulus and question of whether $x$ is large enough are invariant after the first pass meaning that it would be a waste of time.  
+
+The aliases $tmpx1$ and $tmpx2$ refer to the digits of $x$ where the latter is offset by $m$ digits.  By reading digits from $x$ offset by $m$ digits
+a division by $\beta^m$ can be simulated virtually for free.  The loop on line 61 performs the bulk of the work (\textit{corresponds to step 4 of algorithm 7.11})
+in this algorithm.
+
+By line 68 the pointer $tmpx1$ points to the $m$'th digit of $x$ which is where the final carry will be placed.  Similarly by line 71 the 
+same pointer will point to the $m+1$'th digit where the zeroes will be placed.  
+
+Since the algorithm is only valid if both $x$ and $n$ are greater than zero an unsigned comparison suffices to determine if another pass is required.  
+With the same logic at line 82 the value of $x$ is known to be greater than or equal to $n$ meaning that an unsigned subtraction can be used
+as well.  Since the destination of the subtraction is the larger of the inputs the call to algorithm s\_mp\_sub cannot fail and the return code
+does not need to be checked.
+
+\subsubsection{Setup}
+To setup the restricted Diminished Radix algorithm the value $k = \beta - n_0$ is required.  This algorithm is not really complicated but provided for
+completeness.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_dr\_setup}. \\
+\textbf{Input}.   mp\_int $n$ \\
+\textbf{Output}.  $k = \beta - n_0$ \\
+\hline \\
+1.  $k \leftarrow \beta - n_0$ \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_dr\_setup}
+\end{figure}
+
+\index{bn\_mp\_dr\_setup.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_setup.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* determines the setup value */
+018   void mp_dr_setup(mp_int *a, mp_digit *d)
+019   \{
+020      /* the casts are required if DIGIT_BIT is one less than
+021       * the number of bits in a mp_digit [e.g. DIGIT_BIT==31]
+022       */
+023      *d = (mp_digit)((((mp_word)1) << ((mp_word)DIGIT_BIT)) - 
+024           ((mp_word)a->dp[0]));
+025   \}
+026   
+\end{alltt}
+\end{small}
+
+\subsubsection{Modulus Detection}
+Another algorithm which will be useful is the ability to detect a restricted Diminished Radix modulus.  An integer is said to be
+of restricted Diminished Radix form if all of the digits are equal to $\beta - 1$ except the trailing digit which may be any value.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_dr\_is\_modulus}. \\
+\textbf{Input}.   mp\_int $n$ \\
+\textbf{Output}.  $1$ if $n$ is in D.R form, $0$ otherwise \\
+\hline
+1.  If $n.used < 2$ then return($0$). \\
+2.  for $ix$ from $1$ to $n.used - 1$ do \\
+\hspace{3mm}2.1  If $n_{ix} \ne \beta - 1$ return($0$). \\
+3.  Return($1$). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_dr\_is\_modulus}
+\end{figure}
+
+\textbf{Algorithm mp\_dr\_is\_modulus.}
+This algorithm determines if a value is in Diminished Radix form.  Step 1 rejects obvious cases where fewer than two digits are
+in the mp\_int.  Step 2 tests all but the first digit to see if they are equal to $\beta - 1$.  If the algorithm manages to get to
+step 3 then $n$ must of Diminished Radix form.
+
+\index{bn\_mp\_dr\_is\_modulus.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_is\_modulus.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* determines if a number is a valid DR modulus */
+018   int mp_dr_is_modulus(mp_int *a)
+019   \{
+020      int ix;
+021   
+022      /* must be at least two digits */
+023      if (a->used < 2) \{
+024         return 0;
+025      \}
+026   
+027      for (ix = 1; ix < a->used; ix++) \{
+028          if (a->dp[ix] != MP_MASK) \{
+029             return 0;
+030          \}
+031      \}
+032      return 1;
+033   \}
+034   
+\end{alltt}
+\end{small}
+
+\subsection{Unrestricted Diminished Radix Reduction}
+The unrestricted Diminished Radix algorithm allows modular reductions to be performed when the modulus is of the form $2^p - k$.  This algorithm
+is a straightforward adaptation of algorithm~\ref{fig:DR}.
+
+In general the restricted Diminished Radix reduction algorithm is much faster since it has considerably lower overhead.  However, this new
+algorithm is much faster than either Montgomery or Barrett reduction when the moduli are of the appropriate form.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce\_2k}. \\
+\textbf{Input}.   mp\_int $a$ and $n$.  mp\_digit $k$  \\
+\hspace{11.5mm}($a \ge 0$, $n > 1$, $0 < k < \beta$, $n + k$ is a power of two) \\
+\textbf{Output}.  $a \mbox{ (mod }n\mbox{)}$ \\
+\hline
+1.  $p \leftarrow \lfloor lg(n) \rfloor + 1$  (\textit{mp\_count\_bits}) \\
+2.  While $a \ge n$ do \\
+\hspace{3mm}2.1  $q \leftarrow \lfloor a / 2^p \rfloor$ (\textit{mp\_div\_2d}) \\
+\hspace{3mm}2.2  $a \leftarrow a \mbox{ (mod }2^p\mbox{)}$ (\textit{mp\_mod\_2d}) \\
+\hspace{3mm}2.3  $q \leftarrow q \cdot k$ (\textit{mp\_mul\_d}) \\
+\hspace{3mm}2.4  $a \leftarrow a - q$ (\textit{s\_mp\_sub}) \\
+\hspace{3mm}2.5  If $a \ge n$ then do \\
+\hspace{6mm}2.5.1  $a \leftarrow a - n$ \\
+3.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce\_2k}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce\_2k.}
+This algorithm quickly reduces an input $a$ modulo an unrestricted Diminished Radix modulus $n$.
+
+\index{bn\_mp\_reduce\_2k.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_2k.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* reduces a modulo n where n is of the form 2**p - k */
+018   int
+019   mp_reduce_2k(mp_int *a, mp_int *n, mp_digit k)
+020   \{
+021      mp_int q;
+022      int    p, res;
+023      
+024      if ((res = mp_init(&q)) != MP_OKAY) \{
+025         return res;
+026      \}
+027      
+028      p = mp_count_bits(n);    
+029   top:
+030      /* q = a/2**p, a = a mod 2**p */
+031      if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) \{
+032         goto ERR;
+033      \}
+034      
+035      if (k != 1) \{
+036         /* q = q * k */
+037         if ((res = mp_mul_d(&q, k, &q)) != MP_OKAY) \{ 
+038            goto ERR;
+039         \}
+040      \}
+041      
+042      /* a = a + q */
+043      if ((res = s_mp_add(a, &q, a)) != MP_OKAY) \{
+044         goto ERR;
+045      \}
+046      
+047      if (mp_cmp_mag(a, n) != MP_LT) \{
+048         s_mp_sub(a, n, a);
+049         goto top;
+050      \}
+051      
+052   ERR:
+053      mp_clear(&q);
+054      return res;
+055   \}
+056   
+\end{alltt}
+\end{small}
+
+\subsubsection{Unrestricted Setup}
+To setup this reduction algorithm the value of $k = 2^p - n$ is required.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_reduce\_2k\_setup}. \\
+\textbf{Input}.   mp\_int $n$   \\
+\textbf{Output}.  $k = 2^p - n$ \\
+\hline
+1.  $p \leftarrow \lfloor lg(n) \rfloor + 1$  (\textit{mp\_count\_bits}) \\
+2.  $x \leftarrow 2^p$ (\textit{mp\_2expt}) \\
+3.  $x \leftarrow x - n$ (\textit{mp\_sub}) \\
+4.  $k \leftarrow x_0$ \\
+5.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_reduce\_2k\_setup}
+\end{figure}
+
+\textbf{Algorithm mp\_reduce\_2k\_setup.}
+
+\index{bn\_mp\_reduce\_2k\_setup.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_2k\_setup.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* determines the setup value */
+018   int 
+019   mp_reduce_2k_setup(mp_int *a, mp_digit *d)
+020   \{
+021      int res, p;
+022      mp_int tmp;
+023      
+024      if ((res = mp_init(&tmp)) != MP_OKAY) \{
+025         return res;
+026      \}
+027      
+028      p = mp_count_bits(a);
+029      if ((res = mp_2expt(&tmp, p)) != MP_OKAY) \{
+030         mp_clear(&tmp);
+031         return res;
+032      \}
+033      
+034      if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) \{
+035         mp_clear(&tmp);
+036         return res;
+037      \}
+038      
+039      *d = tmp.dp[0];
+040      mp_clear(&tmp);
+041      return MP_OKAY;
+042   \}
+\end{alltt}
+\end{small}
+
+\subsubsection{Unrestricted Detection}
+An integer $n$ is a valid unrestricted Diminished Radix modulus if either of the following are true.
+
+\begin{enumerate}
+\item  The number has only one digit.
+\item  The number has more than one digit and every bit from the $\beta$'th to the most significant is one.
+\end{enumerate}
+
+If either condition is true than there is a power of two namely $2^p$ such that $0 < 2^p - n < \beta$.  
+
+-- Finish this section later, Tom.
+
+\section{Algorithm Comparison}
+So far three very different algorithms for modular reduction have been discussed.  Each of the algorithms have their own strengths and weaknesses
+that makes having such a selection very useful.  The following table sumarizes the three algorithms along with comparisons of work factors.  Since
+all three algorithms have the restriction that $0 \le x < n^2$ and $n > 1$ those limitations are not included in the table.  
+
+\begin{center}
+\begin{small}
+\begin{tabular}{|c|c|c|c|c|c|}
+\hline \textbf{Method} & \textbf{Work Required} & \textbf{Limitations} & \textbf{$m = 8$} & \textbf{$m = 32$} & \textbf{$m = 64$} \\
+\hline Barrett    & $m^2 + 2m - 1$ & None              & $79$ & $1087$ & $4223$ \\
+\hline Montgomery & $m^2 + m$      & $n$ must be odd   & $72$ & $1056$ & $4160$ \\
+\hline D.R.       & $2m$           & $n = \beta^m - k$ & $16$ & $64$   & $128$  \\
+\hline
+\end{tabular}
+\end{small}
+\end{center}
+
+In theory Montgomery and Barrett reductions would require roughly the same amount of time to complete.  However, in practice since Montgomery
+reduction can be written as a single function with the Comba technique it is much faster.  Barrett reduction suffers from the overhead of
+calling the half precision multipliers, addition and division by $\beta$ algorithms.
+
+For almost every cryptographic algorithm Montgomery reduction is the algorithm of choice.  The one set of algorithms where Diminished Radix reduction truly
+shines are based on the discrete logarithm problem such as Diffie-Hellman \cite{DH} and ElGamal \cite{ELGAMAL}.  In these algorithms
+primes of the form $\beta^m - k$ can be found and shared amongst users.  These primes will allow the Diminished Radix algorithm to be used in
+modular exponentiation to greatly speed up the operation.
+
+
+
+\section*{Exercises}
+\begin{tabular}{cl}
+$\left [ 3 \right ]$ & Prove that the ``trick'' in algorithm mp\_montgomery\_setup actually \\
+                     & calculates the correct value of $\rho$. \\
+                     & \\
+$\left [ 2 \right ]$ & Devise an algorithm to reduce modulo $n + k$ for small $k$ quickly.  \\
+                     & \\
+$\left [ 4 \right ]$ & Prove that the pseudo-code algorithm ``Diminished Radix Reduction'' \\
+                     & (\textit{figure 7.10}) terminates.  Also prove the probability that it will \\
+                     & terminate within $1 \le k \le 10$ iterations. \\
+                     & \\
+\end{tabular}                     
+
+
+\chapter{Exponentiation}
+Exponentiation is the operation of raising one variable to the power of another, for example, $a^b$.  A variant of exponentiation, computed
+in a finite field or ring, is called modular exponentiation.  This latter style of operation is typically used in public key 
+cryptosystems such as RSA and Diffie-Hellman.  The ability to quickly compute modular exponentiations is of great benefit to any
+such cryptosystem and many methods have been sought to speed it up.
+
+\section{Exponentiation Basics}
+A trivial algorithm would simply multiply $a$ against itself $b - 1$ times to compute the exponentiation desired.  However, as $b$ grows in size
+the number of multiplications becomes prohibitive.  Imagine what would happen if $b$ $\approx$ $2^{1024}$ as is the case when computing an RSA signature
+with a $1024$-bit key.  Such a calculation could never be completed as it would take simply far too long.
+
+Fortunately there is a very simple algorithm based on the laws of exponents.  Recall that $lg_a(a^b) = b$ and that $lg_a(a^ba^c) = b + c$ which
+are two trivial relationships between the base and the exponent.  Let $b_i$ represent the $i$'th bit of $b$ starting from the least 
+significant bit.  If $b$ is a $k$-bit integer than the following equation is true.
+
+\begin{equation}
+a^b = \prod_{i=0}^{k-1} a^{2^i \cdot b_i}
+\end{equation}
+
+By taking the base $a$ logarithm of both sides of the equation the following equation is the result.
+
+\begin{equation}
+b = \sum_{i=0}^{k-1}2^i \cdot b_i
+\end{equation}
+
+This is indeed true.  The term $a^{2^i}$ can be found from the $i - 1$'th term by squaring the term since $\left ( a^{2^i} \right )^2$ is equal to
+$a^{2^{i+1}}$.  This trivial algorithm forms the basis of essentially all fast exponentiation algorithms.  It requires $k$ squarings and on average
+$k \over 2$ multiplications to compute the result.  This is indeed quite an improvement over simply multiplying by $a$ a total of $b-1$ times.
+
+While this current method is a considerable speed up there are further improvements to be made.  For example, the $a^{2^i}$ term does not need to 
+be an auxilary variable.  Consider the following algorithm.
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Left to Right Exponentiation}. \\
+\textbf{Input}.   Integer $a$, $b$ and $k$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $c \leftarrow 1$ \\
+2.  for $i$ from $k - 1$ to $0$ do \\
+\hspace{3mm}2.1  $c \leftarrow c^2$ \\
+\hspace{3mm}2.2  $c \leftarrow c \cdot a^{b_i}$ \\
+3.  Return $c$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Left to Right Exponentiation}
+\end{figure}
+
+This algorithm starts from the most significant bit and works towards the least significant bit.  When the $i$'th bit of $b$ is set $a$ is
+multiplied against the current product.  In each iteration the product is squared which doubles the exponent of the individual terms of the
+product.  
+
+For example, let $b = 101100_2 \equiv 44_{10}$.  The following chart demonstrates the actions of the algorithm.
+
+\newpage\begin{figure}
+\begin{center}
+\begin{tabular}{|c|c|}
+\hline \textbf{Value of $i$} & \textbf{Value of $c$} \\
+\hline - & $1$ \\
+\hline $5$ & $a$ \\
+\hline $4$ & $a^2$ \\
+\hline $3$ & $a^4 \cdot a$ \\
+\hline $2$ & $a^8 \cdot a^2 \cdot a$ \\
+\hline $1$ & $a^{16} \cdot a^4 \cdot a^2$ \\
+\hline $0$ & $a^{32} \cdot a^8 \cdot a^4$ \\
+\hline
+\end{tabular}
+\end{center}
+\caption{Example of Left to Right Exponentiation}
+\end{figure}
+
+When the product $a^{32} \cdot a^8 \cdot a^4$ is simplified it is equal $a^{44}$ which is the desired exponentiation.  This particular algorithm is 
+called ``Left to Right'' because it reads the exponent in that order.  All of the exponentiation algorithms that will be presented are of this nature.  
+
+\subsection{Single Digit Exponentiation}
+The first algorithm in the series of exponentiation algorithms will be an unbounded algorithm where the exponent is a single digit.  It is intended 
+to be used when a small power of an input is required (\textit{e.g. $a^5$}).  It is faster than simply multiplying $b - 1$ times for all values of 
+$b$ that are greater than three.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_expt\_d}. \\
+\textbf{Input}.   mp\_int $a$ and mp\_digit $b$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $g \leftarrow a$ (\textit{mp\_init\_copy}) \\
+2.  $c \leftarrow 1$ (\textit{mp\_set}) \\
+3.  for $x$ from 0 to $lg(\beta) - 1$ do \\
+\hspace{3mm}3.1  $c \leftarrow c^2$ (\textit{mp\_sqr}) \\
+\hspace{3mm}3.2  If $b$ AND $2^{lg(\beta) - 1} \ne 0$ then \\
+\hspace{6mm}3.2.1  $c \leftarrow c \cdot g$ (\textit{mp\_mul}) \\
+\hspace{3mm}3.3  $b \leftarrow b << 1$ \\
+4.  Clear $g$. \\
+5.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_expt\_d}
+\end{figure}
+
+\textbf{Algorithm mp\_expt\_d.}
+This algorithm computes the value of $a$ raised to the power of a single digit $b$.  It uses the left to right exponentiation algorithm to
+quickly compute the exponentiation.  It is loosely based on algorithm 14.79 of HAC \cite[pp. 615]{HAC} with the difference that the 
+exponent is a fixed width.  
+
+A copy of $a$ is made on the first step to allow destination variable $c$ be the same as the source variable $a$.  The result 
+is set to the initial value of $1$ in the subsequent step.
+
+Inside the loop the exponent is read from the most significant bit first downto the least significant bit.  First $c$ is invariably squared
+on step 3.1.  In the following step if the most significant bit of $b$ is one the copy of $a$ is multiplied against the result.  The value
+of $b$ is shifted left one bit to make the next bit down from the most signficant bit become the new most significant bit.  In effect each
+iteration of the loop moves the bits of the exponent $b$ upwards to the most significant location.
+
+\index{bn\_mp\_expt\_d.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_expt\_d.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* calculate c = a**b  using a square-multiply algorithm */
+018   int
+019   mp_expt_d (mp_int * a, mp_digit b, mp_int * c)
+020   \{
+021     int     res, x;
+022     mp_int  g;
+023   
+024     if ((res = mp_init_copy (&g, a)) != MP_OKAY) \{
+025       return res;
+026     \}
+027   
+028     /* set initial result */
+029     mp_set (c, 1);
+030   
+031     for (x = 0; x < (int) DIGIT_BIT; x++) \{
+032       /* square */
+033       if ((res = mp_sqr (c, c)) != MP_OKAY) \{
+034         mp_clear (&g);
+035         return res;
+036       \}
+037   
+038       /* if the bit is set multiply */
+039       if ((b & (mp_digit) (((mp_digit)1) << (DIGIT_BIT - 1))) != 0) \{
+040         if ((res = mp_mul (c, &g, c)) != MP_OKAY) \{
+041            mp_clear (&g);
+042            return res;
+043         \}
+044       \}
+045   
+046       /* shift to next bit */
+047       b <<= 1;
+048     \}
+049   
+050     mp_clear (&g);
+051     return MP_OKAY;
+052   \}
+\end{alltt}
+\end{small}
+
+-- Some note later.
+
+\subsection{$k$-ary Exponentiation}
+When calculating an exponentiation the most time consuming bottleneck is the multiplications which are in general a small factor
+slower than squaring.  Recall from the previous algorithm that $b_{i}$ refers to the $i$'th bit of the exponent $b$.  Suppose it referred to
+the $i$'th $k$-bit digit of the exponent of $b$.  For $k = 1$ the definitions are synonymous and for $k > 1$ the resulting algorithm
+computes the same exponentiation.  A group of $k$ bits from the exponent is called a \textit{window}.  That is it is a window on a small
+portion of the exponent.  Consider the following modification to the basic left to right exponentiation algorithm.
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{$k$-ary Exponentiation}. \\
+\textbf{Input}.   Integer $a$, $b$, $k$ and $t$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $c \leftarrow 1$ \\
+2.  for $i$ from $t - 1$ to $0$ do \\
+\hspace{3mm}2.1  $c \leftarrow c^{2^k} $ \\
+\hspace{3mm}2.2  Extract the $i$'th $k$-bit word from $b$ and store it in $g$. \\
+\hspace{3mm}2.3  $c \leftarrow c \cdot a^g$ \\
+3.  Return $c$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{$k$-ary Exponentiation}
+\end{figure}
+
+The squaring on step 2.1 can be calculated by squaring the value $c$ successively $k$ times.  If the values of $a^g$ for $0 < g < 2^k$ have been
+precomputed this algorithm requires only $t$ multiplications and $tk$ squarings.  The table can be generated with $2^{k - 1} - 1$ squarings and
+$2^{k - 1} + 1$ multiplications.  This algorithm assumes that the number of bits in the exponent is evenly divisible by $k$.  
+However, when it is not the remaining $0 < x \le k - 1$ bits can be handled with the original left to right style algorithm.
+
+Suppose $k = 4$ and $t = 100$.  This modified algorithm will require $109$ multiplications and $408$ squarings to compute the exponentiation.  The
+original algorithm would on average have required $200$ multiplications and $400$ squrings to compute the same value.  The total number of squarings
+has increased slightly but the number of multiplications has nearly halved.
+
+\subsection{Sliding-Window Exponentiation}
+A simple modification to the previous algorithm is only generate the upper half of the table in the range $2^{k-1} \le g < 2^k$.  Essentially
+this is a table for all values of $g$ where the most significant bit of $g$ is a one.  However, in order for this to be allowed in the 
+algorithm values of $g$ in the range $0 \le g < 2^{k-1}$ must be avoided.  
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{Sliding Window $k$-ary Exponentiation}. \\
+\textbf{Input}.   Integer $a$, $b$, $k$ and $t$ \\
+\textbf{Output}.  $c = a^b$ \\
+\hline \\
+1.  $c \leftarrow 1$ \\
+2.  for $i$ from $t - 1$ to $0$ do \\
+\hspace{3mm}2.1  If the $i$'th bit of $b$ is a zero then \\
+\hspace{6mm}2.1.1   $c \leftarrow c^2$ \\
+\hspace{3mm}2.2  else do \\
+\hspace{6mm}2.2.1  $c \leftarrow c^{2^k}$ \\
+\hspace{6mm}2.2.2  Extract the $k$ bits from $(b_{i}b_{i-1}\ldots b_{i-(k-1)})$ and store it in $g$. \\
+\hspace{6mm}2.2.3  $c \leftarrow c \cdot a^g$ \\
+\hspace{6mm}2.2.4  $i \leftarrow i - k$ \\
+3.  Return $c$. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Sliding Window $k$-ary Exponentiation}
+\end{figure}
+
+Similar to the previous algorithm this algorithm must have a special handler when fewer than $k$ bits are left in the exponent.  While this
+algorithm requires the same number of squarings it can potentially have fewer multiplications.  The pre-computed table $a^g$ is also half
+the size as the previous table.  
+
+Consider the exponent $b = 111101011001000_2 \equiv 31432_{10}$ with $k = 3$ using both algorithms.  The first algorithm will divide the exponent up as 
+the following five $3$-bit words $b \equiv \left ( 111, 101, 011, 001, 000 \right )_{2}$.  The second algorithm will break the 
+exponent as $b \equiv \left ( 111, 101, 0, 110, 0, 100, 0 \right )_{2}$.  The single digit $0$ in the second representation are where
+a single squaring took place instead of a squaring and multiplication.  In total the first method requires $10$ multiplications and $18$ 
+squarings.  The second method requires $8$ multiplications and $18$ squarings.  
+
+In general the sliding window method is never slower than the generic $k$-ary method and often it is slightly faster.  
+
+\section{Modular Exponentiation}
+
+Modular exponentiation is essentially computing the power of a base within a finite field or ring.  For example, computing 
+$d \equiv a^b \mbox{ (mod }c\mbox{)}$ is a modular exponentiation.  Instead of first computing $a^b$ and then reducing it 
+modulo $c$ the intermediate result is reduced modulo $c$ after every squaring or multiplication operation.  
+
+This guarantees that any intermediate result is bounded by $0 \le d \le c^2 - 2c + 1$ and can be reduced modulo $c$ quickly using
+any of the three algorithms presented in chapter seven.  
+
+Before the actual modular exponentiation algorithm can be written a wrapper algorithm must be written first.  This wrapper algorithm
+will allow the exponent $b$ to be negative which is computed as $c \equiv \left (1 / a \right )^{\vert b \vert} \mbox{(mod }d\mbox{)}$. The
+value of $(1/a) \mbox{ mod }c$ is computed using the modular inverse (\textit{see section 10.4}).  If no inverse exists the algorithm
+terminates with an error.  
+
+\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_exptmod}. \\
+\textbf{Input}.   mp\_int $a$, $b$ and $c$ \\
+\textbf{Output}.  $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\
+\hline \\
+1.  If $c.sign = MP\_NEG$ return(\textit{MP\_VAL}). \\
+2.  If $b.sign = MP\_NEG$ then \\
+\hspace{3mm}2.1  $g' \leftarrow g^{-1} \mbox{ (mod }c\mbox{)}$ \\
+\hspace{3mm}2.2  $x' \leftarrow \vert x \vert$ \\
+\hspace{3mm}2.3  Compute $d \equiv g'^{x'} \mbox{ (mod }c\mbox{)}$ via recursion. \\
+3.  if ($p$ is odd \textbf{OR} $p$ is a D.R. modulus) \textbf{AND} $p.used  > 4$ then \\
+\hspace{3mm}3.1  Compute $y \equiv g^{x} \mbox{ (mod }p\mbox{)}$ via algorithm mp\_exptmod\_fast. \\
+4.  else \\
+\hspace{3mm}4.1  Compute $y \equiv g^{x} \mbox{ (mod }p\mbox{)}$ via algorithm s\_mp\_exptmod. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_exptmod}
+\end{figure}
+
+\textbf{Algorithm mp\_exptmod.}
+The first algorithm which actually performs modular exponentiation is algorithm s\_mp\_exptmod.  It is a sliding window $k$-ary algorithm 
+which uses Barrett reduction to reduce the product modulo $p$.  The second algorithm mp\_exptmod\_fast performs the same operation 
+except it uses either Montgomery or Diminished Radix reduction.  The two latter reduction algorithms are clumped in the same exponentiation
+algorithm since their arguments are essentially the same (\textit{two mp\_ints and one mp\_digit}).  
+
+\index{bn\_mp\_exptmod.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_exptmod.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   
+018   /* this is a shell function that calls either the normal or Montgomery
+019    * exptmod functions.  Originally the call to the montgomery code was
+020    * embedded in the normal function but that wasted alot of stack space
+021    * for nothing (since 99% of the time the Montgomery code would be called)
+022    */
+023   int
+024   mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
+025   \{
+026     int dr;
+027   
+028     /* modulus P must be positive */
+029     if (P->sign == MP_NEG) \{
+030        return MP_VAL;
+031     \}
+032   
+033     /* if exponent X is negative we have to recurse */
+034     if (X->sign == MP_NEG) \{
+035        mp_int tmpG, tmpX;
+036        int err;
+037   
+038        /* first compute 1/G mod P */
+039        if ((err = mp_init(&tmpG)) != MP_OKAY) \{
+040           return err;
+041        \}
+042        if ((err = mp_invmod(G, P, &tmpG)) != MP_OKAY) \{
+043           mp_clear(&tmpG);
+044           return err;
+045        \}
+046   
+047        /* now get |X| */
+048        if ((err = mp_init(&tmpX)) != MP_OKAY) \{
+049           mp_clear(&tmpG);
+050           return err;
+051        \}
+052        if ((err = mp_abs(X, &tmpX)) != MP_OKAY) \{
+053           mp_clear_multi(&tmpG, &tmpX, NULL);
+054           return err;
+055        \}
+056   
+057        /* and now compute (1/G)**|X| instead of G**X [X < 0] */
+058        err = mp_exptmod(&tmpG, &tmpX, P, Y);
+059        mp_clear_multi(&tmpG, &tmpX, NULL);
+060        return err;
+061     \}
+062   
+063     dr = mp_dr_is_modulus(P);
+064     if (dr == 0) \{
+065        dr = mp_reduce_is_2k(P) << 1;
+066     \}
+067     
+068     /* if the modulus is odd use the fast method */
+069     if ((mp_isodd (P) == 1 || dr !=  0) && P->used > 4) \{
+070       return mp_exptmod_fast (G, X, P, Y, dr);
+071     \} else \{
+072       return s_mp_exptmod (G, X, P, Y);
+073     \}
+074   \}
+075   
+\end{alltt}
+\end{small}
+
+\subsection{Barrett Modular Exponentiation}
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{s\_mp\_exptmod}. \\
+\textbf{Input}.   mp\_int $a$, $b$ and $c$ \\
+\textbf{Output}.  $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\
+\hline \\
+1.  $k \leftarrow lg(x)$ \\
+2.  $winsize \leftarrow  \left \lbrace \begin{array}{ll}
+                              2 &  \mbox{if }k \le 7 \\
+                              3 &  \mbox{if }7 < k \le 36 \\
+                              4 &  \mbox{if }36 < k \le 140 \\
+                              5 &  \mbox{if }140 < k \le 450 \\
+                              6 &  \mbox{if }450 < k \le 1303 \\
+                              7 &  \mbox{if }1303 < k \le 3529 \\
+                              8 &  \mbox{if }3529 < k \\
+                              \end{array} \right .$ \\
+3.  Initialize $2^{winsize}$ mp\_ints in an array named $M$ and one mp\_int named $\mu$ \\
+4.  Calculate the $\mu$ required for Barrett Reduction (\textit{mp\_reduce\_setup}). \\
+5.  $M_1 \leftarrow g \mbox{ (mod }p\mbox{)}$ \\
+\\
+Setup the table of small powers of $g$.  First find $g^{2^{winsize}}$ and then all multiples of it. \\
+6.  $k \leftarrow 2^{winsize - 1}$ \\
+7.  $M_{k} \leftarrow M_1$ \\
+8.  for $ix$ from 0 to $winsize - 2$ do \\
+\hspace{3mm}8.1  $M_k \leftarrow \left ( M_k \right )^2$ \\
+\hspace{3mm}8.2  $M_k \leftarrow M_k \mbox{ (mod }p\mbox{)}$ (\textit{mp\_reduce}) \\
+9.  for $ix$ from $2^{winsize - 1} + 1$ to $2^{winsize} - 1$ do \\
+\hspace{3mm}9.1  $M_{ix} \leftarrow M_{ix - 1} \cdot M_{1}$ \\
+\hspace{3mm}9.2  $M_{ix} \leftarrow M_{ix} \mbox{ (mod }p\mbox{)}$ (\textit{mp\_reduce}) \\
+10.  $res \leftarrow 1$ \\
+\\
+Start Sliding Window. \\
+11.  $mode \leftarrow 0, bitcnt \leftarrow 1, buf \leftarrow 0, digidx \leftarrow x.used - 1, bitcpy \leftarrow 0, bitbuf \leftarrow 0$ \\
+12.  Loop \\
+\hspace{3mm}12.1  $bitcnt \leftarrow bitcnt - 1$ \\
+\hspace{3mm}12.2  If $bitcnt = 0$ then do \\
+\hspace{6mm}12.2.1  If $digidx = -1$ goto step 13. \\
+\hspace{6mm}12.2.2  $buf \leftarrow x_{digidx}$ \\
+\hspace{6mm}12.2.3  $digidx \leftarrow digidx - 1$ \\
+\hspace{6mm}12.2.4  $bitcnt \leftarrow lg(\beta)$ \\
+Continued on next page. \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm s\_mp\_exptmod}
+\end{figure}
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{s\_mp\_exptmod} (\textit{continued}). \\
+\textbf{Input}.   mp\_int $a$, $b$ and $c$ \\
+\textbf{Output}.  $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\
+\hline \\
+\hspace{3mm}12.3  $y \leftarrow (buf >> (lg(\beta) - 1))$ AND $1$ \\
+\hspace{3mm}12.4  $buf \leftarrow buf << 1$ \\
+\hspace{3mm}12.5  if $mode = 0$ and $y = 0$ then goto step 12. \\
+\hspace{3mm}12.6  if $mode = 1$ and $y = 0$ then do \\
+\hspace{6mm}12.6.1  $res \leftarrow res^2$ \\
+\hspace{6mm}12.6.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}12.6.3  Goto step 12. \\
+\hspace{3mm}12.7  $bitcpy \leftarrow bitcpy + 1$ \\
+\hspace{3mm}12.8  $bitbuf \leftarrow bitbuf + (y << (winsize - bitcpy))$ \\
+\hspace{3mm}12.9  $mode \leftarrow 2$ \\
+\hspace{3mm}12.10  If $bitcpy = winsize$ then do \\
+\hspace{6mm}Window is full so perform the squarings and single multiplication. \\
+\hspace{6mm}12.10.1  for $ix$ from $0$ to $winsize -1$ do \\
+\hspace{9mm}12.10.1.1  $res \leftarrow res^2$ \\
+\hspace{9mm}12.10.1.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}12.10.2  $res \leftarrow res \cdot M_{bitbuf}$ \\
+\hspace{6mm}12.10.3  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}Reset the window. \\
+\hspace{6mm}12.10.4  $bitcpy \leftarrow 0, bitbuf \leftarrow 0, mode \leftarrow 1$ \\
+\\
+No more windows left.  Check for residual bits of exponent. \\
+13.  If $mode = 2$ and $bitcpy > 0$ then do \\
+\hspace{3mm}13.1  for $ix$ form $0$ to $bitcpy - 1$ do \\
+\hspace{6mm}13.1.1  $res \leftarrow res^2$ \\
+\hspace{6mm}13.1.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+\hspace{6mm}13.1.3  $bitbuf \leftarrow bitbuf << 1$ \\
+\hspace{6mm}13.1.4  If $bitbuf$ AND $2^{winsize} \ne 0$ then do \\
+\hspace{9mm}13.1.4.1  $res \leftarrow res \cdot M_{1}$ \\
+\hspace{9mm}13.1.4.2  $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\
+14.  $y \leftarrow res$ \\
+15.  Clear $res$, $mu$ and the $M$ array. \\
+16.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm s\_mp\_exptmod (continued)}
+\end{figure}
+
+\textbf{Algorithm s\_mp\_exptmod.}
+This algorithm computes the $x$'th power of $g$ modulo $p$ and stores the result in $y$.  It takes advantage of the Barrett reduction
+algorithm to keep the product small throughout the algorithm.
+
+The first two steps determine the optimal window size based on the number of bits in the exponent.  The larger the exponent the 
+larger the window size becomes.  After a window size $winsize$ has been chosen an array of $2^{winsize}$ mp\_int variables is allocated.  This
+table will hold the values of $g^x \mbox{ (mod }p\mbox{)}$ for $2^{winsize - 1} \le x < 2^{winsize}$.  
+
+After the table is allocated the first power of $g$ is found.  Since $g \ge p$ is allowed it must be first reduced modulo $p$ to make
+the rest of the algorithm more efficient.  The first element of the table at $2^{winsize - 1}$ is found by squaring $M_1$ successively $winsize - 2$
+times.  The rest of the table elements are found by multiplying the previous element by $M_1$ modulo $p$.
+
+Now that the table is available the sliding window may begin.  The following list describes the functions of all the variables in the window.
+\begin{enumerate}
+\item The variable $mode$ dictates how the bits of the exponent are interpreted.  
+\begin{enumerate}
+   \item When $mode = 0$ the bits are ignored since no non-zero bit of the exponent has been seen yet.  For example, if the exponent were simply 
+         $1$ then there would be $lg(\beta) - 1$ zero bits before the first non-zero bit.  In this case bits are ignored until a non-zero bit is found.  
+   \item When $mode = 1$ a non-zero bit has been seen before and a new $winsize$-bit window has not been formed yet.  In this mode leading $0$ bits 
+         are read and a single squaring is performed.  If a non-zero bit is read a new window is created.  
+   \item When $mode = 2$ the algorithm is in the middle of forming a window and new bits are appended to the window from the most significant bit
+         downards.
+\end{enumerate}
+\item The variable $bitcnt$ indicates how many bits are left in the current digit of the exponent left to be read.  When it reaches zero a new digit
+      is fetched from the exponent.
+\item The variable $buf$ holds the currently read digit of the exponent. 
+\item The variable $digidx$ is an index into the exponents digits.  It starts at the leading digit $x.used - 1$ and moves towards the trailing digit.
+\item The variable $bitcpy$ indicates how many bits are in the currently formed window.  When it reaches $winsize$ the window is flushed and
+      the appropriate operations performed.
+\item The variable $bitbuf$ holds the current bits of the window being formed.  
+\end{enumerate}
+
+All of step 12 is the window processing loop.  It will iterate while there are digits available form the exponent to read.  The first step
+inside this loop is to extract a new digit if no more bits are available in the current digit.  If there are no bits left a new digit is
+read and if there are no digits left than the loop terminates.  
+
+After a digit is made available step 12.3 will extract the most significant bit of the current digit and move all other bits in the digit
+upwards.  In effect the digit is read from most significant bit to least significant bit and since the digits are read from leading to 
+trailing edges the entire exponent is read from most significant bit to least significant bit.
+
+At step 12.5 if the $mode$ and currently extracted bit $y$ are both zero the bit is ignored and the next bit is read.  This prevents the 
+algorithm from having todo trivial squaring and reduction operations before the first non-zero bit is read.  Step 12.6 and 12.7-10 handle
+the two cases of $mode = 1$ and $mode = 2$ respectively.  
+
+\begin{center}
+\begin{figure}[here]
+\includegraphics{pics/expt_state.ps}
+\caption{Sliding Window State Diagram}
+\end{figure}
+\end{center}
+
+By step 13 there are no more digits left in the exponent.  However, there may be partial bits in the window left.  If $mode = 2$ then 
+a Left-to-Right algorithm is used to process the remaining few bits.  
+
+\index{bn\_s\_mp\_exptmod.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_exptmod.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   int
+018   s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y)
+019   \{
+020     mp_int  M[256], res, mu;
+021     mp_digit buf;
+022     int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
+023   
+024     /* find window size */
+025     x = mp_count_bits (X);
+026     if (x <= 7) \{
+027       winsize = 2;
+028     \} else if (x <= 36) \{
+029       winsize = 3;
+030     \} else if (x <= 140) \{
+031       winsize = 4;
+032     \} else if (x <= 450) \{
+033       winsize = 5;
+034     \} else if (x <= 1303) \{
+035       winsize = 6;
+036     \} else if (x <= 3529) \{
+037       winsize = 7;
+038     \} else \{
+039       winsize = 8;
+040     \}
+041   
+042   #ifdef MP_LOW_MEM
+043       if (winsize > 5) \{
+044          winsize = 5;
+045       \}
+046   #endif
+047   
+048     /* init M array */
+049     for (x = 0; x < (1 << winsize); x++) \{
+050       if ((err = mp_init_size (&M[x], 1)) != MP_OKAY) \{
+051         for (y = 0; y < x; y++) \{
+052           mp_clear (&M[y]);
+053         \}
+054         return err;
+055       \}
+056     \}
+057   
+058     /* create mu, used for Barrett reduction */
+059     if ((err = mp_init (&mu)) != MP_OKAY) \{
+060       goto __M;
+061     \}
+062     if ((err = mp_reduce_setup (&mu, P)) != MP_OKAY) \{
+063       goto __MU;
+064     \}
+065   
+066     /* create M table
+067      *
+068      * The M table contains powers of the input base, e.g. M[x] = G**x mod P
+069      *
+070      * The first half of the table is not computed though accept for M[0] and 
+      M[1]
+071      */
+072     if ((err = mp_mod (G, P, &M[1])) != MP_OKAY) \{
+073       goto __MU;
+074     \}
+075   
+076     /* compute the value at M[1<<(winsize-1)] by squaring M[1] (winsize-1) tim
+      es */
+077     if ((err = mp_copy (&M[1], &M[1 << (winsize - 1)])) != MP_OKAY) \{
+078       goto __MU;
+079     \}
+080   
+081     for (x = 0; x < (winsize - 1); x++) \{
+082       if ((err = mp_sqr (&M[1 << (winsize - 1)], &M[1 << (winsize - 1)])) != M
+      P_OKAY) \{
+083         goto __MU;
+084       \}
+085       if ((err = mp_reduce (&M[1 << (winsize - 1)], P, &mu)) != MP_OKAY) \{
+086         goto __MU;
+087       \}
+088     \}
+089   
+090     /* create upper table */
+091     for (x = (1 << (winsize - 1)) + 1; x < (1 << winsize); x++) \{
+092       if ((err = mp_mul (&M[x - 1], &M[1], &M[x])) != MP_OKAY) \{
+093         goto __MU;
+094       \}
+095       if ((err = mp_reduce (&M[x], P, &mu)) != MP_OKAY) \{
+096         goto __MU;
+097       \}
+098     \}
+099   
+100     /* setup result */
+101     if ((err = mp_init (&res)) != MP_OKAY) \{
+102       goto __MU;
+103     \}
+104     mp_set (&res, 1);
+105   
+106     /* set initial mode and bit cnt */
+107     mode   = 0;
+108     bitcnt = 1;
+109     buf    = 0;
+110     digidx = X->used - 1;
+111     bitcpy = bitbuf = 0;
+112   
+113     for (;;) \{
+114       /* grab next digit as required */
+115       if (--bitcnt == 0) \{
+116         if (digidx == -1) \{
+117           break;
+118         \}
+119         buf = X->dp[digidx--];
+120         bitcnt = (int) DIGIT_BIT;
+121       \}
+122   
+123       /* grab the next msb from the exponent */
+124       y = (buf >> (mp_digit)(DIGIT_BIT - 1)) & 1;
+125       buf <<= (mp_digit)1;
+126   
+127       /* if the bit is zero and mode == 0 then we ignore it
+128        * These represent the leading zero bits before the first 1 bit
+129        * in the exponent.  Technically this opt is not required but it
+130        * does lower the # of trivial squaring/reductions used
+131        */
+132       if (mode == 0 && y == 0)
+133         continue;
+134   
+135       /* if the bit is zero and mode == 1 then we square */
+136       if (mode == 1 && y == 0) \{
+137         if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
+138           goto __RES;
+139         \}
+140         if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+141           goto __RES;
+142         \}
+143         continue;
+144       \}
+145   
+146       /* else we add it to the window */
+147       bitbuf |= (y << (winsize - ++bitcpy));
+148       mode = 2;
+149   
+150       if (bitcpy == winsize) \{
+151         /* ok window is filled so square as required and multiply  */
+152         /* square first */
+153         for (x = 0; x < winsize; x++) \{
+154           if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
+155             goto __RES;
+156           \}
+157           if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+158             goto __RES;
+159           \}
+160         \}
+161   
+162         /* then multiply */
+163         if ((err = mp_mul (&res, &M[bitbuf], &res)) != MP_OKAY) \{
+164           goto __MU;
+165         \}
+166         if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+167           goto __MU;
+168         \}
+169   
+170         /* empty window and reset */
+171         bitcpy = bitbuf = 0;
+172         mode = 1;
+173       \}
+174     \}
+175   
+176     /* if bits remain then square/multiply */
+177     if (mode == 2 && bitcpy > 0) \{
+178       /* square then multiply if the bit is set */
+179       for (x = 0; x < bitcpy; x++) \{
+180         if ((err = mp_sqr (&res, &res)) != MP_OKAY) \{
+181           goto __RES;
+182         \}
+183         if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+184           goto __RES;
+185         \}
+186   
+187         bitbuf <<= 1;
+188         if ((bitbuf & (1 << winsize)) != 0) \{
+189           /* then multiply */
+190           if ((err = mp_mul (&res, &M[1], &res)) != MP_OKAY) \{
+191             goto __RES;
+192           \}
+193           if ((err = mp_reduce (&res, P, &mu)) != MP_OKAY) \{
+194             goto __RES;
+195           \}
+196         \}
+197       \}
+198     \}
+199   
+200     mp_exch (&res, Y);
+201     err = MP_OKAY;
+202   __RES:mp_clear (&res);
+203   __MU:mp_clear (&mu);
+204   __M:
+205     for (x = 0; x < (1 << winsize); x++) \{
+206       mp_clear (&M[x]);
+207     \}
+208     return err;
+209   \}
+\end{alltt}
+\end{small}
+
+\section{Quick Power of Two}
+Calculating $b = 2^a$ can be performed much quicker than with any of the previous algorithms.  Recall that a logical shift left $m << k$ is
+equivalent to $m \cdot 2^k$.  By this logic when $m = 1$ a quick power of two can be achieved.
+
+\newpage\begin{figure}[!here]
+\begin{small}
+\begin{center}
+\begin{tabular}{l}
+\hline Algorithm \textbf{mp\_2expt}. \\
+\textbf{Input}.   integer $b$ \\
+\textbf{Output}.  $a \leftarrow 2^b$ \\
+\hline \\
+1.  $a \leftarrow 0$ \\
+2.  If $a.alloc < \lfloor b / lg(\beta) \rfloor + 1$ then grow $a$ appropriately. \\
+3.  $a.used \leftarrow \lfloor b / lg(\beta) \rfloor + 1$ \\
+4.  $a_{\lfloor b / lg(\beta) \rfloor} \leftarrow 1 << (b \mbox{ mod } lg(\beta))$ \\
+5.  Return(\textit{MP\_OKAY}). \\
+\hline
+\end{tabular}
+\end{center}
+\end{small}
+\caption{Algorithm mp\_2expt}
+\end{figure}
+
+\textbf{Algorithm mp\_2expt.}
+
+\index{bn\_mp\_2expt.c}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: bn\_mp\_2expt.c
+\vspace{-3mm}
+\begin{alltt}
+016   
+017   /* computes a = 2**b 
+018    *
+019    * Simple algorithm which zeroes the int, grows it then just sets one bit
+020    * as required.
+021    */
+022   int
+023   mp_2expt (mp_int * a, int b)
+024   \{
+025     int     res;
+026   
+027     mp_zero (a);
+028     if ((res = mp_grow (a, b / DIGIT_BIT + 1)) != MP_OKAY) \{
+029       return res;
+030     \}
+031     a->used = b / DIGIT_BIT + 1;
+032     a->dp[b / DIGIT_BIT] = 1 << (b % DIGIT_BIT);
+033   
+034     return MP_OKAY;
+035   \}
+\end{alltt}
+\end{small}
+
+
+\chapter{Higher Level Algorithms}
+\section{Integer Division with Remainder}
+
+\section{Single Digit Helpers}
+\subsection{Single Digit Addition}
+\subsection{Single Digit Subtraction}
+\subsection{Single Digit Multiplication}
+\subsection{Single Digit Division}
+\subsection{Single Digit Modulo}
+\subsection{Single Digit Root Extraction}
+\section{Random Number Generation}
+\section{Formatted Output}
+\subsection{Getting The Output Size}
+\subsection{Generating Radix-n Output}
+\subsection{Reading Radix-n Input}
+\section{Unformatted Output}
+\subsection{Getting The Output Size}
+\subsection{Generating Output}
+\subsection{Reading Input}
+
+\chapter{Number Theoretic Algorithms}
+\section{Greatest Common Divisor}
+\section{Least Common Multiple}
+\section{Jacobi Symbol Computation}
+\section{Modular Inverse}
+\subsection{General Case}
+\subsection{Odd Moduli}
+\section{Primality Tests}
+\subsection{Trial Division}
+\subsection{The Fermat Test}
+\subsection{The Miller-Rabin Test}
+\subsection{Primality Test in a Bottle}
+\subsection{The Next Prime}
+\section{Root Extraction}
+
+\backmatter
+\appendix
+\begin{thebibliography}{ABCDEF}
+\bibitem[1]{TAOCPV2}
+Donald Knuth, \textit{The Art of Computer Programming}, Third Edition, Volume Two, Seminumerical Algorithms, Addison-Wesley, 1998
+
+\bibitem[2]{HAC}
+A. Menezes, P. van Oorschot, S. Vanstone, \textit{Handbook of Applied Cryptography}, CRC Press, 1996
+
+\bibitem[3]{ROSE}
+Michael Rosing, \textit{Implementing Elliptic Curve Cryptography}, Manning Publications, 1999
+
+\bibitem[4]{COMBA}
+Paul G. Comba, \textit{Exponentiation Cryptosystems on the IBM PC}. IBM Systems Journal 29(4): 526-538 (1990)
+
+\bibitem[5]{KARA}
+A. Karatsuba, Doklay Akad. Nauk SSSR 145 (1962), pp.293-294
+
+\bibitem[6]{KARAP}
+Andre Weimerskirch and Christof Paar, \textit{Generalizations of the Karatsuba Algorithm for Polynomial Multiplication}, Submitted to Design, Codes and Cryptography, March 2002
+
+\bibitem[7]{BARRETT}
+Paul Barrett, \textit{Implementing the Rivest Shamir and Adleman Public Key Encryption Algorithm on a Standard Digital Signal Processor}, Advances in Cryptology, Crypto '86, Springer-Verlag.
+
+\bibitem[8]{MONT}
+P.L.Montgomery. \textit{Modular multiplication without trial division}. Mathematics of Computation, 44(170):519-521, April 1985.
+
+\bibitem[9]{DRMET}
+Chae Hoon Lim and Pil Joong Lee, \textit{Generating Efficient Primes for Discrete Log Cryptosystems}, POSTECH Information Research Laboratories
+
+\bibitem[10]{MMB}
+J. Daemen and R. Govaerts and J. Vandewalle, \textit{Block ciphers based on Modular Arithmetic}, State and {P}rogress in the {R}esearch of {C}ryptography, 1993, pp. 80-89
+
+\end{thebibliography}
+
+\input{tommath.ind}
+
+\chapter{Appendix}
+\subsection*{Appendix A -- Source Listing of tommath.h}
+
+The following is the source listing of the header file ``tommath.h'' for the LibTomMath project.  It contains many of 
+the definitions used throughout the code such as \textbf{mp\_int}, \textbf{MP\_PREC} and so on.  The header is 
+presented here for completeness.
+
+\index{tommath.h}
+\vspace{+3mm}\begin{small}
+\hspace{-5.1mm}{\bf File}: tommath.h
+\vspace{-3mm}
+\begin{alltt}
+001   /* LibTomMath, multiple-precision integer library -- Tom St Denis
 002    *
 003    * LibTomMath is library that provides for multiple-precision
 004    * integer arithmetic as well as number theoretic functionality.
@@ -3815,7 +7079,7 @@ presented here for completeness.
 069      
 070      /* this is to make porting into LibTomCrypt easier :-) */
 071   #ifndef CRYPT
-072      #ifdef _MSC_VER
+072      #if defined(_MSC_VER) || defined(__BORLANDC__) 
 073         typedef unsigned __int64   ulong64;
 074         typedef signed __int64     long64;
 075      #else
@@ -3827,368 +7091,388 @@ presented here for completeness.
 081      typedef unsigned long      mp_digit;
 082      typedef ulong64            mp_word;
 083   
-084      #define DIGIT_BIT          28
-085   #endif
-086   
-087   /* otherwise the bits per digit is calculated automatically from the size of
+084   #ifdef MP_31BIT   
+085      #define DIGIT_BIT          31
+086   #else
+087      #define DIGIT_BIT          28
+088   #endif   
+089   #endif
+090   
+091   /* otherwise the bits per digit is calculated automatically from the size of
        a mp_digit */
-088   #ifndef DIGIT_BIT
-089      #define DIGIT_BIT     ((CHAR_BIT * sizeof(mp_digit) - 1))  /* bits per di
+092   #ifndef DIGIT_BIT
+093      #define DIGIT_BIT     ((CHAR_BIT * sizeof(mp_digit) - 1))  /* bits per di
       git */
-090   #endif
-091   
-092   
-093   #define MP_DIGIT_BIT     DIGIT_BIT
-094   #define MP_MASK          ((((mp_digit)1)<<((mp_digit)DIGIT_BIT))-((mp_digit)
-      1))
-095   #define MP_DIGIT_MAX     MP_MASK
+094   #endif
+095   
 096   
-097   /* equalities */
-098   #define MP_LT        -1   /* less than */
-099   #define MP_EQ         0   /* equal to */
-100   #define MP_GT         1   /* greater than */
-101   
-102   #define MP_ZPOS       0   /* positive integer */
-103   #define MP_NEG        1   /* negative */
-104   
-105   #define MP_OKAY       0   /* ok result */
-106   #define MP_MEM        -2  /* out of mem */
-107   #define MP_VAL        -3  /* invalid input */
-108   #define MP_RANGE      MP_VAL
-109   
-110   typedef int           mp_err;
-111   
-112   /* you'll have to tune these... */
-113   extern int KARATSUBA_MUL_CUTOFF,
-114              KARATSUBA_SQR_CUTOFF,
-115              MONTGOMERY_EXPT_CUTOFF;
-116   
-117   /* various build options */
-118   #define MP_PREC                 64      /* default digits of precision (must
+097   #define MP_DIGIT_BIT     DIGIT_BIT
+098   #define MP_MASK          ((((mp_digit)1)<<((mp_digit)DIGIT_BIT))-((mp_digit)
+      1))
+099   #define MP_DIGIT_MAX     MP_MASK
+100   
+101   /* equalities */
+102   #define MP_LT        -1   /* less than */
+103   #define MP_EQ         0   /* equal to */
+104   #define MP_GT         1   /* greater than */
+105   
+106   #define MP_ZPOS       0   /* positive integer */
+107   #define MP_NEG        1   /* negative */
+108   
+109   #define MP_OKAY       0   /* ok result */
+110   #define MP_MEM        -2  /* out of mem */
+111   #define MP_VAL        -3  /* invalid input */
+112   #define MP_RANGE      MP_VAL
+113   
+114   typedef int           mp_err;
+115   
+116   /* you'll have to tune these... */
+117   extern int KARATSUBA_MUL_CUTOFF,
+118              KARATSUBA_SQR_CUTOFF,
+119              TOOM_MUL_CUTOFF,
+120              TOOM_SQR_CUTOFF;
+121   
+122   /* various build options */
+123   #define MP_PREC                 64      /* default digits of precision (must
        be power of two) */
-119   
-120   /* define this to use lower memory usage routines (exptmods mostly) */
-121   /* #define MP_LOW_MEM */
-122   
-123   /* size of comba arrays, should be at least 2 * 2**(BITS_PER_WORD - BITS_PER
+124   
+125   /* define this to use lower memory usage routines (exptmods mostly) */
+126   /* #define MP_LOW_MEM */
+127   
+128   /* size of comba arrays, should be at least 2 * 2**(BITS_PER_WORD - BITS_PER
       _DIGIT*2) */
-124   #define MP_WARRAY               (1 << (sizeof(mp_word) * CHAR_BIT - 2 * DIGI
+129   #define MP_WARRAY               (1 << (sizeof(mp_word) * CHAR_BIT - 2 * DIGI
       T_BIT + 1))
-125   
-126   typedef struct  \{
-127       int used, alloc, sign;
-128       mp_digit *dp;
-129   \} mp_int;
 130   
-131   #define USED(m)    ((m)->used)
-132   #define DIGIT(m,k) ((m)->dp[k])
-133   #define SIGN(m)    ((m)->sign)
-134   
-135   /* ---> init and deinit bignum functions <--- */
-136   
-137   /* init a bignum */
-138   int mp_init(mp_int *a);
+131   typedef struct  \{
+132       int used, alloc, sign;
+133       mp_digit *dp;
+134   \} mp_int;
+135   
+136   #define USED(m)    ((m)->used)
+137   #define DIGIT(m,k) ((m)->dp[k])
+138   #define SIGN(m)    ((m)->sign)
 139   
-140   /* free a bignum */
-141   void mp_clear(mp_int *a);
-142   
-143   /* init a null terminated series of arguments */
-144   int mp_init_multi(mp_int *mp, ...);
-145   
-146   /* clear a null terminated series of arguments */
-147   void mp_clear_multi(mp_int *mp, ...);
-148   
-149   /* exchange two ints */
-150   void mp_exch(mp_int *a, mp_int *b);
-151   
-152   /* shrink ram required for a bignum */
-153   int mp_shrink(mp_int *a);
-154   
-155   /* grow an int to a given size */
-156   int mp_grow(mp_int *a, int size);
-157   
-158   /* init to a given number of digits */
-159   int mp_init_size(mp_int *a, int size);
-160   
-161   /* ---> Basic Manipulations <--- */
+140   /* ---> init and deinit bignum functions <--- */
+141   
+142   /* init a bignum */
+143   int mp_init(mp_int *a);
+144   
+145   /* free a bignum */
+146   void mp_clear(mp_int *a);
+147   
+148   /* init a null terminated series of arguments */
+149   int mp_init_multi(mp_int *mp, ...);
+150   
+151   /* clear a null terminated series of arguments */
+152   void mp_clear_multi(mp_int *mp, ...);
+153   
+154   /* exchange two ints */
+155   void mp_exch(mp_int *a, mp_int *b);
+156   
+157   /* shrink ram required for a bignum */
+158   int mp_shrink(mp_int *a);
+159   
+160   /* grow an int to a given size */
+161   int mp_grow(mp_int *a, int size);
 162   
-163   #define mp_iszero(a) (((a)->used == 0) ? 1 : 0)
-164   #define mp_iseven(a) (((a)->used == 0 || (((a)->dp[0] & 1) == 0)) ? 1 : 0)
-165   #define mp_isodd(a)  (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? 1 : 0)
-166   
-167   /* set to zero */
-168   void mp_zero(mp_int *a);
-169   
-170   /* set to a digit */
-171   void mp_set(mp_int *a, mp_digit b);
-172   
-173   /* set a 32-bit const */
-174   int mp_set_int(mp_int *a, unsigned int b);
-175   
-176   /* copy, b = a */
-177   int mp_copy(mp_int *a, mp_int *b);
-178   
-179   /* inits and copies, a = b */
-180   int mp_init_copy(mp_int *a, mp_int *b);
-181   
-182   /* trim unused digits */
-183   void mp_clamp(mp_int *a);
-184   
-185   /* ---> digit manipulation <--- */
+163   /* init to a given number of digits */
+164   int mp_init_size(mp_int *a, int size);
+165   
+166   /* ---> Basic Manipulations <--- */
+167   
+168   #define mp_iszero(a) (((a)->used == 0) ? 1 : 0)
+169   #define mp_iseven(a) (((a)->used == 0 || (((a)->dp[0] & 1) == 0)) ? 1 : 0)
+170   #define mp_isodd(a)  (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? 1 : 0)
+171   
+172   /* set to zero */
+173   void mp_zero(mp_int *a);
+174   
+175   /* set to a digit */
+176   void mp_set(mp_int *a, mp_digit b);
+177   
+178   /* set a 32-bit const */
+179   int mp_set_int(mp_int *a, unsigned int b);
+180   
+181   /* copy, b = a */
+182   int mp_copy(mp_int *a, mp_int *b);
+183   
+184   /* inits and copies, a = b */
+185   int mp_init_copy(mp_int *a, mp_int *b);
 186   
-187   /* right shift by "b" digits */
-188   void mp_rshd(mp_int *a, int b);
+187   /* trim unused digits */
+188   void mp_clamp(mp_int *a);
 189   
-190   /* left shift by "b" digits */
-191   int mp_lshd(mp_int *a, int b);
-192   
-193   /* c = a / 2**b */
-194   int mp_div_2d(mp_int *a, int b, mp_int *c, mp_int *d);
-195   
-196   /* b = a/2 */
-197   int mp_div_2(mp_int *a, mp_int *b);
-198   
-199   /* c = a * 2**b */
-200   int mp_mul_2d(mp_int *a, int b, mp_int *c);
-201   
-202   /* b = a*2 */
-203   int mp_mul_2(mp_int *a, mp_int *b);
-204   
-205   /* c = a mod 2**d */
-206   int mp_mod_2d(mp_int *a, int b, mp_int *c);
-207   
-208   /* computes a = 2**b */
-209   int mp_2expt(mp_int *a, int b);
-210   
-211   /* makes a pseudo-random int of a given size */
-212   int mp_rand(mp_int *a, int digits);
-213   
-214   /* ---> binary operations <--- */
-215   /* c = a XOR b  */
-216   int mp_xor(mp_int *a, mp_int *b, mp_int *c);
-217   
-218   /* c = a OR b */
-219   int mp_or(mp_int *a, mp_int *b, mp_int *c);
-220   
-221   /* c = a AND b */
-222   int mp_and(mp_int *a, mp_int *b, mp_int *c);
-223   
-224   /* ---> Basic arithmetic <--- */
+190   /* ---> digit manipulation <--- */
+191   
+192   /* right shift by "b" digits */
+193   void mp_rshd(mp_int *a, int b);
+194   
+195   /* left shift by "b" digits */
+196   int mp_lshd(mp_int *a, int b);
+197   
+198   /* c = a / 2**b */
+199   int mp_div_2d(mp_int *a, int b, mp_int *c, mp_int *d);
+200   
+201   /* b = a/2 */
+202   int mp_div_2(mp_int *a, mp_int *b);
+203   
+204   /* c = a * 2**b */
+205   int mp_mul_2d(mp_int *a, int b, mp_int *c);
+206   
+207   /* b = a*2 */
+208   int mp_mul_2(mp_int *a, mp_int *b);
+209   
+210   /* c = a mod 2**d */
+211   int mp_mod_2d(mp_int *a, int b, mp_int *c);
+212   
+213   /* computes a = 2**b */
+214   int mp_2expt(mp_int *a, int b);
+215   
+216   /* makes a pseudo-random int of a given size */
+217   int mp_rand(mp_int *a, int digits);
+218   
+219   /* ---> binary operations <--- */
+220   /* c = a XOR b  */
+221   int mp_xor(mp_int *a, mp_int *b, mp_int *c);
+222   
+223   /* c = a OR b */
+224   int mp_or(mp_int *a, mp_int *b, mp_int *c);
 225   
-226   /* b = -a */
-227   int mp_neg(mp_int *a, mp_int *b);
+226   /* c = a AND b */
+227   int mp_and(mp_int *a, mp_int *b, mp_int *c);
 228   
-229   /* b = |a| */
-230   int mp_abs(mp_int *a, mp_int *b);
-231   
-232   /* compare a to b */
-233   int mp_cmp(mp_int *a, mp_int *b);
-234   
-235   /* compare |a| to |b| */
-236   int mp_cmp_mag(mp_int *a, mp_int *b);
-237   
-238   /* c = a + b */
-239   int mp_add(mp_int *a, mp_int *b, mp_int *c);
-240   
-241   /* c = a - b */
-242   int mp_sub(mp_int *a, mp_int *b, mp_int *c);
-243   
-244   /* c = a * b */
-245   int mp_mul(mp_int *a, mp_int *b, mp_int *c);
-246   
-247   /* b = a*a  */
-248   int mp_sqr(mp_int *a, mp_int *b);
-249   
-250   /* a/b => cb + d == a */
-251   int mp_div(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
-252   
-253   /* c = a mod b, 0 <= c < b  */
-254   int mp_mod(mp_int *a, mp_int *b, mp_int *c);
-255   
-256   /* ---> single digit functions <--- */
+229   /* ---> Basic arithmetic <--- */
+230   
+231   /* b = -a */
+232   int mp_neg(mp_int *a, mp_int *b);
+233   
+234   /* b = |a| */
+235   int mp_abs(mp_int *a, mp_int *b);
+236   
+237   /* compare a to b */
+238   int mp_cmp(mp_int *a, mp_int *b);
+239   
+240   /* compare |a| to |b| */
+241   int mp_cmp_mag(mp_int *a, mp_int *b);
+242   
+243   /* c = a + b */
+244   int mp_add(mp_int *a, mp_int *b, mp_int *c);
+245   
+246   /* c = a - b */
+247   int mp_sub(mp_int *a, mp_int *b, mp_int *c);
+248   
+249   /* c = a * b */
+250   int mp_mul(mp_int *a, mp_int *b, mp_int *c);
+251   
+252   /* b = a*a  */
+253   int mp_sqr(mp_int *a, mp_int *b);
+254   
+255   /* a/b => cb + d == a */
+256   int mp_div(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
 257   
-258   /* compare against a single digit */
-259   int mp_cmp_d(mp_int *a, mp_digit b);
+258   /* c = a mod b, 0 <= c < b  */
+259   int mp_mod(mp_int *a, mp_int *b, mp_int *c);
 260   
-261   /* c = a + b */
-262   int mp_add_d(mp_int *a, mp_digit b, mp_int *c);
-263   
-264   /* c = a - b */
-265   int mp_sub_d(mp_int *a, mp_digit b, mp_int *c);
-266   
-267   /* c = a * b */
-268   int mp_mul_d(mp_int *a, mp_digit b, mp_int *c);
-269   
-270   /* a/b => cb + d == a */
-271   int mp_div_d(mp_int *a, mp_digit b, mp_int *c, mp_digit *d);
-272   
-273   /* c = a**b */
-274   int mp_expt_d(mp_int *a, mp_digit b, mp_int *c);
-275   
-276   /* c = a mod b, 0 <= c < b  */
-277   int mp_mod_d(mp_int *a, mp_digit b, mp_digit *c);
-278   
-279   /* ---> number theory <--- */
+261   /* ---> single digit functions <--- */
+262   
+263   /* compare against a single digit */
+264   int mp_cmp_d(mp_int *a, mp_digit b);
+265   
+266   /* c = a + b */
+267   int mp_add_d(mp_int *a, mp_digit b, mp_int *c);
+268   
+269   /* c = a - b */
+270   int mp_sub_d(mp_int *a, mp_digit b, mp_int *c);
+271   
+272   /* c = a * b */
+273   int mp_mul_d(mp_int *a, mp_digit b, mp_int *c);
+274   
+275   /* a/b => cb + d == a */
+276   int mp_div_d(mp_int *a, mp_digit b, mp_int *c, mp_digit *d);
+277   
+278   /* a/3 => 3c + d == a */
+279   int mp_div_3(mp_int *a, mp_int *c, mp_digit *d);
 280   
-281   /* d = a + b (mod c) */
-282   int mp_addmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+281   /* c = a**b */
+282   int mp_expt_d(mp_int *a, mp_digit b, mp_int *c);
 283   
-284   /* d = a - b (mod c) */
-285   int mp_submod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+284   /* c = a mod b, 0 <= c < b  */
+285   int mp_mod_d(mp_int *a, mp_digit b, mp_digit *c);
 286   
-287   /* d = a * b (mod c) */
-288   int mp_mulmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
-289   
-290   /* c = a * a (mod b) */
-291   int mp_sqrmod(mp_int *a, mp_int *b, mp_int *c);
-292   
-293   /* c = 1/a (mod b) */
-294   int mp_invmod(mp_int *a, mp_int *b, mp_int *c);
-295   
-296   /* c = (a, b) */
-297   int mp_gcd(mp_int *a, mp_int *b, mp_int *c);
-298   
-299   /* c = [a, b] or (a*b)/(a, b) */
-300   int mp_lcm(mp_int *a, mp_int *b, mp_int *c);
-301   
-302   /* finds one of the b'th root of a, such that |c|**b <= |a|
-303    *
-304    * returns error if a < 0 and b is even
-305    */
-306   int mp_n_root(mp_int *a, mp_digit b, mp_int *c);
-307   
-308   /* shortcut for square root */
-309   #define mp_sqrt(a, b) mp_n_root(a, 2, b)
-310   
-311   /* computes the jacobi c = (a | n) (or Legendre if b is prime)  */
-312   int mp_jacobi(mp_int *a, mp_int *n, int *c);
-313   
-314   /* used to setup the Barrett reduction for a given modulus b */
-315   int mp_reduce_setup(mp_int *a, mp_int *b);
-316   
-317   /* Barrett Reduction, computes a (mod b) with a precomputed value c
-318    *
-319    * Assumes that 0 < a <= b*b, note if 0 > a > -(b*b) then you can merely
-320    * compute the reduction as -1 * mp_reduce(mp_abs(a)) [pseudo code].
-321    */
-322   int mp_reduce(mp_int *a, mp_int *b, mp_int *c);
-323   
-324   /* setups the montgomery reduction */
-325   int mp_montgomery_setup(mp_int *a, mp_digit *mp);
-326   
-327   /* computes a = B**n mod b without division or multiplication useful for
-328    * normalizing numbers in a Montgomery system.
+287   /* ---> number theory <--- */
+288   
+289   /* d = a + b (mod c) */
+290   int mp_addmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+291   
+292   /* d = a - b (mod c) */
+293   int mp_submod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+294   
+295   /* d = a * b (mod c) */
+296   int mp_mulmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+297   
+298   /* c = a * a (mod b) */
+299   int mp_sqrmod(mp_int *a, mp_int *b, mp_int *c);
+300   
+301   /* c = 1/a (mod b) */
+302   int mp_invmod(mp_int *a, mp_int *b, mp_int *c);
+303   
+304   /* c = (a, b) */
+305   int mp_gcd(mp_int *a, mp_int *b, mp_int *c);
+306   
+307   /* c = [a, b] or (a*b)/(a, b) */
+308   int mp_lcm(mp_int *a, mp_int *b, mp_int *c);
+309   
+310   /* finds one of the b'th root of a, such that |c|**b <= |a|
+311    *
+312    * returns error if a < 0 and b is even
+313    */
+314   int mp_n_root(mp_int *a, mp_digit b, mp_int *c);
+315   
+316   /* shortcut for square root */
+317   #define mp_sqrt(a, b) mp_n_root(a, 2, b)
+318   
+319   /* computes the jacobi c = (a | n) (or Legendre if b is prime)  */
+320   int mp_jacobi(mp_int *a, mp_int *n, int *c);
+321   
+322   /* used to setup the Barrett reduction for a given modulus b */
+323   int mp_reduce_setup(mp_int *a, mp_int *b);
+324   
+325   /* Barrett Reduction, computes a (mod b) with a precomputed value c
+326    *
+327    * Assumes that 0 < a <= b*b, note if 0 > a > -(b*b) then you can merely
+328    * compute the reduction as -1 * mp_reduce(mp_abs(a)) [pseudo code].
 329    */
-330   int mp_montgomery_calc_normalization(mp_int *a, mp_int *b);
+330   int mp_reduce(mp_int *a, mp_int *b, mp_int *c);
 331   
-332   /* computes x/R == x (mod N) via Montgomery Reduction */
-333   int mp_montgomery_reduce(mp_int *a, mp_int *m, mp_digit mp);
+332   /* setups the montgomery reduction */
+333   int mp_montgomery_setup(mp_int *a, mp_digit *mp);
 334   
-335   /* returns 1 if a is a valid DR modulus */
-336   int mp_dr_is_modulus(mp_int *a);
-337   
-338   /* sets the value of "d" required for mp_dr_reduce */
-339   void mp_dr_setup(mp_int *a, mp_digit *d);
-340   
-341   /* reduces a modulo b using the Diminished Radix method */
-342   int mp_dr_reduce(mp_int *a, mp_int *b, mp_digit mp);
-343   
-344   /* d = a**b (mod c) */
-345   int mp_exptmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
-346   
-347   /* ---> Primes <--- */
+335   /* computes a = B**n mod b without division or multiplication useful for
+336    * normalizing numbers in a Montgomery system.
+337    */
+338   int mp_montgomery_calc_normalization(mp_int *a, mp_int *b);
+339   
+340   /* computes x/R == x (mod N) via Montgomery Reduction */
+341   int mp_montgomery_reduce(mp_int *a, mp_int *m, mp_digit mp);
+342   
+343   /* returns 1 if a is a valid DR modulus */
+344   int mp_dr_is_modulus(mp_int *a);
+345   
+346   /* sets the value of "d" required for mp_dr_reduce */
+347   void mp_dr_setup(mp_int *a, mp_digit *d);
 348   
-349   /* number of primes */
-350   #ifdef MP_8BIT
-351      #define PRIME_SIZE      31
-352   #else
-353      #define PRIME_SIZE      256
-354   #endif
-355   
-356   /* table of first PRIME_SIZE primes */
-357   extern const mp_digit __prime_tab[];
-358   
-359   /* result=1 if a is divisible by one of the first PRIME_SIZE primes */
-360   int mp_prime_is_divisible(mp_int *a, int *result);
-361   
-362   /* performs one Fermat test of "a" using base "b".
-363    * Sets result to 0 if composite or 1 if probable prime
-364    */
-365   int mp_prime_fermat(mp_int *a, mp_int *b, int *result);
-366   
-367   /* performs one Miller-Rabin test of "a" using base "b".
-368    * Sets result to 0 if composite or 1 if probable prime
-369    */
-370   int mp_prime_miller_rabin(mp_int *a, mp_int *b, int *result);
-371   
-372   /* performs t rounds of Miller-Rabin on "a" using the first
-373    * t prime bases.  Also performs an initial sieve of trial
-374    * division.  Determines if "a" is prime with probability
-375    * of error no more than (1/4)**t.
-376    *
-377    * Sets result to 1 if probably prime, 0 otherwise
-378    */
-379   int mp_prime_is_prime(mp_int *a, int t, int *result);
-380   
-381   /* finds the next prime after the number "a" using "t" trials
-382    * of Miller-Rabin.
-383    */
-384   int mp_prime_next_prime(mp_int *a, int t);
-385   
-386   
-387   /* ---> radix conversion <--- */
-388   int mp_count_bits(mp_int *a);
-389   
-390   int mp_unsigned_bin_size(mp_int *a);
-391   int mp_read_unsigned_bin(mp_int *a, unsigned char *b, int c);
-392   int mp_to_unsigned_bin(mp_int *a, unsigned char *b);
-393   
-394   int mp_signed_bin_size(mp_int *a);
-395   int mp_read_signed_bin(mp_int *a, unsigned char *b, int c);
-396   int mp_to_signed_bin(mp_int *a, unsigned char *b);
+349   /* reduces a modulo b using the Diminished Radix method */
+350   int mp_dr_reduce(mp_int *a, mp_int *b, mp_digit mp);
+351   
+352   /* returns true if a can be reduced with mp_reduce_2k */
+353   int mp_reduce_is_2k(mp_int *a);
+354   
+355   /* determines k value for 2k reduction */
+356   int mp_reduce_2k_setup(mp_int *a, mp_digit *d);
+357   
+358   /* reduces a modulo b where b is of the form 2**p - k [0 <= a] */
+359   int mp_reduce_2k(mp_int *a, mp_int *n, mp_digit k);
+360   
+361   /* d = a**b (mod c) */
+362   int mp_exptmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+363   
+364   /* ---> Primes <--- */
+365   
+366   /* number of primes */
+367   #ifdef MP_8BIT
+368      #define PRIME_SIZE      31
+369   #else
+370      #define PRIME_SIZE      256
+371   #endif
+372   
+373   /* table of first PRIME_SIZE primes */
+374   extern const mp_digit __prime_tab[];
+375   
+376   /* result=1 if a is divisible by one of the first PRIME_SIZE primes */
+377   int mp_prime_is_divisible(mp_int *a, int *result);
+378   
+379   /* performs one Fermat test of "a" using base "b".
+380    * Sets result to 0 if composite or 1 if probable prime
+381    */
+382   int mp_prime_fermat(mp_int *a, mp_int *b, int *result);
+383   
+384   /* performs one Miller-Rabin test of "a" using base "b".
+385    * Sets result to 0 if composite or 1 if probable prime
+386    */
+387   int mp_prime_miller_rabin(mp_int *a, mp_int *b, int *result);
+388   
+389   /* performs t rounds of Miller-Rabin on "a" using the first
+390    * t prime bases.  Also performs an initial sieve of trial
+391    * division.  Determines if "a" is prime with probability
+392    * of error no more than (1/4)**t.
+393    *
+394    * Sets result to 1 if probably prime, 0 otherwise
+395    */
+396   int mp_prime_is_prime(mp_int *a, int t, int *result);
 397   
-398   int mp_read_radix(mp_int *a, char *str, int radix);
-399   int mp_toradix(mp_int *a, char *str, int radix);
-400   int mp_radix_size(mp_int *a, int radix);
-401   
-402   int mp_fread(mp_int *a, int radix, FILE *stream);
-403   int mp_fwrite(mp_int *a, int radix, FILE *stream);
-404   
-405   #define mp_read_raw(mp, str, len) mp_read_signed_bin((mp), (str), (len))
-406   #define mp_raw_size(mp)           mp_signed_bin_size(mp)
-407   #define mp_toraw(mp, str)         mp_to_signed_bin((mp), (str))
-408   #define mp_read_mag(mp, str, len) mp_read_unsigned_bin((mp), (str), (len))
-409   #define mp_mag_size(mp)           mp_unsigned_bin_size(mp)
-410   #define mp_tomag(mp, str)         mp_to_unsigned_bin((mp), (str))
-411   
-412   #define mp_tobinary(M, S)  mp_toradix((M), (S), 2)
-413   #define mp_tooctal(M, S)   mp_toradix((M), (S), 8)
-414   #define mp_todecimal(M, S) mp_toradix((M), (S), 10)
-415   #define mp_tohex(M, S)     mp_toradix((M), (S), 16)
-416   
-417   /* lowlevel functions, do not call! */
-418   int s_mp_add(mp_int *a, mp_int *b, mp_int *c);
-419   int s_mp_sub(mp_int *a, mp_int *b, mp_int *c);
-420   #define s_mp_mul(a, b, c) s_mp_mul_digs(a, b, c, (a)->used + (b)->used + 1)
-421   int fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
-422   int s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
-423   int fast_s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
-424   int s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
-425   int fast_s_mp_sqr(mp_int *a, mp_int *b);
-426   int s_mp_sqr(mp_int *a, mp_int *b);
-427   int mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c);
-428   int mp_karatsuba_sqr(mp_int *a, mp_int *b);
-429   int fast_mp_invmod(mp_int *a, mp_int *b, mp_int *c);
-430   int fast_mp_montgomery_reduce(mp_int *a, mp_int *m, mp_digit mp);
-431   int mp_exptmod_fast(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int mode);
-432   void bn_reverse(unsigned char *s, int len);
+398   /* finds the next prime after the number "a" using "t" trials
+399    * of Miller-Rabin.
+400    */
+401   int mp_prime_next_prime(mp_int *a, int t);
+402   
+403   
+404   /* ---> radix conversion <--- */
+405   int mp_count_bits(mp_int *a);
+406   
+407   int mp_unsigned_bin_size(mp_int *a);
+408   int mp_read_unsigned_bin(mp_int *a, unsigned char *b, int c);
+409   int mp_to_unsigned_bin(mp_int *a, unsigned char *b);
+410   
+411   int mp_signed_bin_size(mp_int *a);
+412   int mp_read_signed_bin(mp_int *a, unsigned char *b, int c);
+413   int mp_to_signed_bin(mp_int *a, unsigned char *b);
+414   
+415   int mp_read_radix(mp_int *a, char *str, int radix);
+416   int mp_toradix(mp_int *a, char *str, int radix);
+417   int mp_radix_size(mp_int *a, int radix);
+418   
+419   int mp_fread(mp_int *a, int radix, FILE *stream);
+420   int mp_fwrite(mp_int *a, int radix, FILE *stream);
+421   
+422   #define mp_read_raw(mp, str, len) mp_read_signed_bin((mp), (str), (len))
+423   #define mp_raw_size(mp)           mp_signed_bin_size(mp)
+424   #define mp_toraw(mp, str)         mp_to_signed_bin((mp), (str))
+425   #define mp_read_mag(mp, str, len) mp_read_unsigned_bin((mp), (str), (len))
+426   #define mp_mag_size(mp)           mp_unsigned_bin_size(mp)
+427   #define mp_tomag(mp, str)         mp_to_unsigned_bin((mp), (str))
+428   
+429   #define mp_tobinary(M, S)  mp_toradix((M), (S), 2)
+430   #define mp_tooctal(M, S)   mp_toradix((M), (S), 8)
+431   #define mp_todecimal(M, S) mp_toradix((M), (S), 10)
+432   #define mp_tohex(M, S)     mp_toradix((M), (S), 16)
 433   
-434   #ifdef __cplusplus
-435      \}
-436   #endif
-437   
-438   #endif
-439   
+434   /* lowlevel functions, do not call! */
+435   int s_mp_add(mp_int *a, mp_int *b, mp_int *c);
+436   int s_mp_sub(mp_int *a, mp_int *b, mp_int *c);
+437   #define s_mp_mul(a, b, c) s_mp_mul_digs(a, b, c, (a)->used + (b)->used + 1)
+438   int fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
+439   int s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
+440   int fast_s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
+441   int s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
+442   int fast_s_mp_sqr(mp_int *a, mp_int *b);
+443   int s_mp_sqr(mp_int *a, mp_int *b);
+444   int mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c);
+445   int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c);
+446   int mp_karatsuba_sqr(mp_int *a, mp_int *b);
+447   int mp_toom_sqr(mp_int *a, mp_int *b);
+448   int fast_mp_invmod(mp_int *a, mp_int *b, mp_int *c);
+449   int fast_mp_montgomery_reduce(mp_int *a, mp_int *m, mp_digit mp);
+450   int mp_exptmod_fast(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int mode);
+451   int s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y);
+452   void bn_reverse(unsigned char *s, int len);
+453   
+454   #ifdef __cplusplus
+455      \}
+456   #endif
+457   
+458   #endif
+459   
 \end{alltt}
 \end{small}
kc3-lang/libtommath

Commit 0ef44cea9bde015f5c630384dcc6ccee34b618ad
