Lots of code cleanup, mainly [https://github.com/libtom/libtommath/pull/102|Pull request #102]

83 files changed, 365 insertions, 314 deletions

diff --git a/libtommath/README.md b/libtommath/README.md
index 4c5da71..3bc491d 100644
--- a/libtommath/README.md
+++ b/libtommath/README.md
@@ -1,8 +1,14 @@
-[![Build Status - master](https://travis-ci.org/libtom/libtommath.png?branch=master)](https://travis-ci.org/libtom/libtommath)
+# libtommath
 
-[![Build Status - develop](https://travis-ci.org/libtom/libtommath.png?branch=develop)](https://travis-ci.org/libtom/libtommath)
+This is the git repository for [LibTomMath](http://www.libtom.net/LibTomMath/), a free open source portable number theoretic multiple-precision integer (MPI) library written entirely in C.
 
-This is the git repository for [LibTomMath](http://www.libtom.org/), a free open source portable number theoretic multiple-precision integer (MPI) library written entirely in C.
+## Build Status
+
+master  - [![Build Status - master](https://travis-ci.org/libtom/libtommath.png?branch=master)](https://travis-ci.org/libtom/libtommath)
+
+develop - [![Build Status - develop](https://travis-ci.org/libtom/libtommath.png?branch=develop)](https://travis-ci.org/libtom/libtommath)
+
+## Summary
 
 The `develop` branch contains the in-development version. Stable releases are tagged.
 
@@ -10,6 +16,8 @@ Documentation is built from the LaTeX file `bn.tex`. There is also limited docum
 
 The project can be build by using `make`. Along with the usual `make`, `make clean` and `make install`, there are several other build targets, see the makefile for details. There are also makefiles for certain specific platforms.
 
+## Testing
+
 Tests are located in `demo/` and can be built in two flavors.
 * `make test` creates a test binary that is intended to be run against `mtest`. `mtest` can be built with `make mtest` and test execution is done like `./mtest/mtest | ./test`. `mtest` is creating test vectors using an alternative MPI library and `test` is consuming these vectors to verify correct behavior of ltm
 * `make test_standalone` creates a stand-alone test binary that executes several test routines.
diff --git a/libtommath/bn_error.c b/libtommath/bn_error.c
index a51d712..7e816bf 100644
--- a/libtommath/bn_error.c
+++ b/libtommath/bn_error.c
@@ -27,10 +27,10 @@ static const struct {
 /* return a char * string for a given code */
 const char *mp_error_to_string(int code)
 {
-   int x;
+   size_t x;
 
    /* scan the lookup table for the given message */
-   for (x = 0; x < (int)(sizeof(msgs) / sizeof(msgs[0])); x++) {
+   for (x = 0; x < (sizeof(msgs) / sizeof(msgs[0])); x++) {
       if (msgs[x].code == code) {
          return msgs[x].msg;
       }
diff --git a/libtommath/bn_fast_mp_invmod.c b/libtommath/bn_fast_mp_invmod.c
index 08389dd..6be44f8 100644
--- a/libtommath/bn_fast_mp_invmod.c
+++ b/libtommath/bn_fast_mp_invmod.c
@@ -46,6 +46,12 @@ int fast_mp_invmod(const mp_int *a, const mp_int *b, mp_int *c)
       goto LBL_ERR;
    }
 
+   /* if one of x,y is zero return an error! */
+   if ((mp_iszero(&x) == MP_YES) || (mp_iszero(&y) == MP_YES)) {
+      res = MP_VAL;
+      goto LBL_ERR;
+   }
+
    /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */
    if ((res = mp_copy(&x, &u)) != MP_OKAY) {
       goto LBL_ERR;
@@ -53,7 +59,7 @@ int fast_mp_invmod(const mp_int *a, const mp_int *b, mp_int *c)
    if ((res = mp_copy(&y, &v)) != MP_OKAY) {
       goto LBL_ERR;
    }
-   mp_set(&D, 1);
+   mp_set(&D, 1uL);
 
 top:
    /* 4.  while u is even do */
@@ -122,7 +128,7 @@ top:
    /* now a = C, b = D, gcd == g*v */
 
    /* if v != 1 then there is no inverse */
-   if (mp_cmp_d(&v, 1) != MP_EQ) {
+   if (mp_cmp_d(&v, 1uL) != MP_EQ) {
       res = MP_VAL;
       goto LBL_ERR;
    }
diff --git a/libtommath/bn_fast_mp_montgomery_reduce.c b/libtommath/bn_fast_mp_montgomery_reduce.c
index 54d9b0a..8f91196 100644
--- a/libtommath/bn_fast_mp_montgomery_reduce.c
+++ b/libtommath/bn_fast_mp_montgomery_reduce.c
@@ -28,6 +28,10 @@ int fast_mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
    int     ix, res, olduse;
    mp_word W[MP_WARRAY];
 
+   if (x->used > (int)MP_WARRAY) {
+      return MP_VAL;
+   }
+
    /* get old used count */
    olduse = x->used;
 
@@ -73,7 +77,7 @@ int fast_mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
        * that W[ix-1] have  the carry cleared (see after the inner loop)
        */
       mp_digit mu;
-      mu = (mp_digit)(((W[ix] & MP_MASK) * rho) & MP_MASK);
+      mu = ((W[ix] & MP_MASK) * rho) & MP_MASK;
 
       /* a = a + mu * m * b**i
        *
@@ -102,12 +106,12 @@ int fast_mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
 
          /* inner loop */
          for (iy = 0; iy < n->used; iy++) {
-            *_W++ += ((mp_word)mu) * ((mp_word)*tmpn++);
+            *_W++ += (mp_word)mu * (mp_word)*tmpn++;
          }
       }
 
       /* now fix carry for next digit, W[ix+1] */
-      W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT);
+      W[ix + 1] += W[ix] >> (mp_word)DIGIT_BIT;
    }
 
    /* now we have to propagate the carries and
@@ -127,7 +131,7 @@ int fast_mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
       _W = W + ++ix;
 
       for (; ix <= ((n->used * 2) + 1); ix++) {
-         *_W++ += *_W1++ >> ((mp_word) DIGIT_BIT);
+         *_W++ += *_W1++ >> (mp_word)DIGIT_BIT;
       }
 
       /* copy out, A = A/b**n
@@ -144,7 +148,7 @@ int fast_mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
       _W = W + n->used;
 
       for (ix = 0; ix < (n->used + 1); ix++) {
-         *tmpx++ = (mp_digit)(*_W++ & ((mp_word) MP_MASK));
+         *tmpx++ = *_W++ & (mp_word)MP_MASK;
       }
 
       /* zero oldused digits, if the input a was larger than
diff --git a/libtommath/bn_fast_s_mp_mul_digs.c b/libtommath/bn_fast_s_mp_mul_digs.c
index 558d151..e542c2e 100644
--- a/libtommath/bn_fast_s_mp_mul_digs.c
+++ b/libtommath/bn_fast_s_mp_mul_digs.c
@@ -69,15 +69,15 @@ int fast_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
 
       /* execute loop */
       for (iz = 0; iz < iy; ++iz) {
-         _W += ((mp_word)*tmpx++)*((mp_word)*tmpy--);
+         _W += (mp_word)*tmpx++ * (mp_word)*tmpy--;
 
       }
 
       /* store term */
-      W[ix] = ((mp_digit)_W) & MP_MASK;
+      W[ix] = (mp_digit)_W & MP_MASK;
 
       /* make next carry */
-      _W = _W >> ((mp_word)DIGIT_BIT);
+      _W = _W >> (mp_word)DIGIT_BIT;
    }
 
    /* setup dest */
@@ -87,7 +87,7 @@ int fast_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
    {
       mp_digit *tmpc;
       tmpc = c->dp;
-      for (ix = 0; ix < (pa + 1); ix++) {
+      for (ix = 0; ix < pa; ix++) {
          /* now extract the previous digit [below the carry] */
          *tmpc++ = W[ix];
       }
diff --git a/libtommath/bn_fast_s_mp_mul_high_digs.c b/libtommath/bn_fast_s_mp_mul_high_digs.c
index 8b662ed..6ea8a6c 100644
--- a/libtommath/bn_fast_s_mp_mul_high_digs.c
+++ b/libtommath/bn_fast_s_mp_mul_high_digs.c
@@ -60,14 +60,14 @@ int fast_s_mp_mul_high_digs(const mp_int *a, const mp_int *b, mp_int *c, int dig
 
       /* execute loop */
       for (iz = 0; iz < iy; iz++) {
-         _W += ((mp_word)*tmpx++)*((mp_word)*tmpy--);
+         _W += (mp_word)*tmpx++ * (mp_word)*tmpy--;
       }
 
       /* store term */
-      W[ix] = ((mp_digit)_W) & MP_MASK;
+      W[ix] = (mp_digit)_W & MP_MASK;
 
       /* make next carry */
-      _W = _W >> ((mp_word)DIGIT_BIT);
+      _W = _W >> (mp_word)DIGIT_BIT;
    }
 
    /* setup dest */
diff --git a/libtommath/bn_fast_s_mp_sqr.c b/libtommath/bn_fast_s_mp_sqr.c
index 161f785..1050121 100644
--- a/libtommath/bn_fast_s_mp_sqr.c
+++ b/libtommath/bn_fast_s_mp_sqr.c
@@ -70,22 +70,22 @@ int fast_s_mp_sqr(const mp_int *a, mp_int *b)
 
       /* execute loop */
       for (iz = 0; iz < iy; iz++) {
-         _W += ((mp_word)*tmpx++)*((mp_word)*tmpy--);
+         _W += (mp_word)*tmpx++ * (mp_word)*tmpy--;
       }
 
       /* double the inner product and add carry */
       _W = _W + _W + W1;
 
       /* even columns have the square term in them */
-      if ((ix&1) == 0) {
-         _W += ((mp_word)a->dp[ix>>1])*((mp_word)a->dp[ix>>1]);
+      if (((unsigned)ix & 1u) == 0u) {
+         _W += (mp_word)a->dp[ix>>1] * (mp_word)a->dp[ix>>1];
       }
 
       /* store it */
-      W[ix] = (mp_digit)(_W & MP_MASK);
+      W[ix] = _W & MP_MASK;
 
       /* make next carry */
-      W1 = _W >> ((mp_word)DIGIT_BIT);
+      W1 = _W >> (mp_word)DIGIT_BIT;
    }
 
    /* setup dest */
diff --git a/libtommath/bn_mp_2expt.c b/libtommath/bn_mp_2expt.c
index 701144c..5333d48 100644
--- a/libtommath/bn_mp_2expt.c
+++ b/libtommath/bn_mp_2expt.c
@@ -36,7 +36,7 @@ int mp_2expt(mp_int *a, int b)
    a->used = (b / DIGIT_BIT) + 1;
 
    /* put the single bit in its place */
-   a->dp[b / DIGIT_BIT] = ((mp_digit)1) << (b % DIGIT_BIT);
+   a->dp[b / DIGIT_BIT] = (mp_digit)1 << (mp_digit)(b % DIGIT_BIT);
 
    return MP_OKAY;
 }
diff --git a/libtommath/bn_mp_clamp.c b/libtommath/bn_mp_clamp.c
index 3853914..79a5b20 100644
--- a/libtommath/bn_mp_clamp.c
+++ b/libtommath/bn_mp_clamp.c
@@ -27,7 +27,7 @@ void mp_clamp(mp_int *a)
    /* decrease used while the most significant digit is
     * zero.
     */
-   while ((a->used > 0) && (a->dp[a->used - 1] == 0)) {
+   while ((a->used > 0) && (a->dp[a->used - 1] == 0u)) {
       --(a->used);
    }
 
diff --git a/libtommath/bn_mp_clear_multi.c b/libtommath/bn_mp_clear_multi.c
index 284fab8..ac3949a 100644
--- a/libtommath/bn_mp_clear_multi.c
+++ b/libtommath/bn_mp_clear_multi.c
@@ -14,6 +14,7 @@
  *
  * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
  */
+
 #include <stdarg.h>
 
 void mp_clear_multi(mp_int *mp, ...)
diff --git a/libtommath/bn_mp_cnt_lsb.c b/libtommath/bn_mp_cnt_lsb.c
index 9a94d3d..219c369 100644
--- a/libtommath/bn_mp_cnt_lsb.c
+++ b/libtommath/bn_mp_cnt_lsb.c
@@ -31,17 +31,17 @@ int mp_cnt_lsb(const mp_int *a)
    }
 
    /* scan lower digits until non-zero */
-   for (x = 0; (x < a->used) && (a->dp[x] == 0); x++) {}
+   for (x = 0; (x < a->used) && (a->dp[x] == 0u); x++) {}
    q = a->dp[x];
    x *= DIGIT_BIT;
 
    /* now scan this digit until a 1 is found */
-   if ((q & 1) == 0) {
+   if ((q & 1u) == 0u) {
       do {
-         qq  = q & 15;
+         qq  = q & 15u;
          x  += lnz[qq];
          q >>= 4;
-      } while (qq == 0);
+      } while (qq == 0u);
    }
    return x;
 }
diff --git a/libtommath/bn_mp_count_bits.c b/libtommath/bn_mp_count_bits.c
index 7424581..4530c92 100644
--- a/libtommath/bn_mp_count_bits.c
+++ b/libtommath/bn_mp_count_bits.c
@@ -31,9 +31,9 @@ int mp_count_bits(const mp_int *a)
 
    /* take the last digit and count the bits in it */
    q = a->dp[a->used - 1];
-   while (q > ((mp_digit) 0)) {
+   while (q > (mp_digit)0) {
       ++r;
-      q >>= ((mp_digit) 1);
+      q >>= (mp_digit)1;
    }
    return r;
 }
diff --git a/libtommath/bn_mp_div.c b/libtommath/bn_mp_div.c
index dbfdc03..f64f485 100644
--- a/libtommath/bn_mp_div.c
+++ b/libtommath/bn_mp_div.c
@@ -47,7 +47,7 @@ int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
    }
 
 
-   mp_set(&tq, 1);
+   mp_set(&tq, 1uL);
    n = mp_count_bits(a) - mp_count_bits(b);
    if (((res = mp_abs(a, &ta)) != MP_OKAY) ||
        ((res = mp_abs(b, &tb)) != MP_OKAY) ||
@@ -150,8 +150,8 @@ int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
 
    /* normalize both x and y, ensure that y >= b/2, [b == 2**DIGIT_BIT] */
    norm = mp_count_bits(&y) % DIGIT_BIT;
-   if (norm < (int)(DIGIT_BIT-1)) {
-      norm = (DIGIT_BIT-1) - norm;
+   if (norm < (DIGIT_BIT - 1)) {
+      norm = (DIGIT_BIT - 1) - norm;
       if ((res = mp_mul_2d(&x, norm, &x)) != MP_OKAY) {
          goto LBL_Y;
       }
@@ -190,16 +190,16 @@ int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
       /* step 3.1 if xi == yt then set q{i-t-1} to b-1,
        * otherwise set q{i-t-1} to (xi*b + x{i-1})/yt */
       if (x.dp[i] == y.dp[t]) {
-         q.dp[(i - t) - 1] = ((((mp_digit)1) << DIGIT_BIT) - 1);
+         q.dp[(i - t) - 1] = ((mp_digit)1 << (mp_digit)DIGIT_BIT) - (mp_digit)1;
       } else {
          mp_word tmp;
-         tmp = ((mp_word) x.dp[i]) << ((mp_word) DIGIT_BIT);
-         tmp |= ((mp_word) x.dp[i - 1]);
-         tmp /= ((mp_word) y.dp[t]);
-         if (tmp > (mp_word) MP_MASK) {
+         tmp = (mp_word)x.dp[i] << (mp_word)DIGIT_BIT;
+         tmp |= (mp_word)x.dp[i - 1];
+         tmp /= (mp_word)y.dp[t];
+         if (tmp > (mp_word)MP_MASK) {
             tmp = MP_MASK;
          }
-         q.dp[(i - t) - 1] = (mp_digit)(tmp & (mp_word)(MP_MASK));
+         q.dp[(i - t) - 1] = (mp_digit)(tmp & (mp_word)MP_MASK);
       }
 
       /* while (q{i-t-1} * (yt * b + y{t-1})) >
@@ -207,13 +207,13 @@ int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
 
          do q{i-t-1} -= 1;
       */
-      q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] + 1) & MP_MASK;
+      q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] + 1uL) & (mp_digit)MP_MASK;
       do {
-         q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1) & MP_MASK;
+         q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1uL) & (mp_digit)MP_MASK;
 
          /* find left hand */
          mp_zero(&t1);
-         t1.dp[0] = ((t - 1) < 0) ? 0 : y.dp[t - 1];
+         t1.dp[0] = ((t - 1) < 0) ? 0u : y.dp[t - 1];
          t1.dp[1] = y.dp[t];
          t1.used = 2;
          if ((res = mp_mul_d(&t1, q.dp[(i - t) - 1], &t1)) != MP_OKAY) {
@@ -221,8 +221,8 @@ int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
          }
 
          /* find right hand */
-         t2.dp[0] = ((i - 2) < 0) ? 0 : x.dp[i - 2];
-         t2.dp[1] = ((i - 1) < 0) ? 0 : x.dp[i - 1];
+         t2.dp[0] = ((i - 2) < 0) ? 0u : x.dp[i - 2];
+         t2.dp[1] = ((i - 1) < 0) ? 0u : x.dp[i - 1];
          t2.dp[2] = x.dp[i];
          t2.used = 3;
       } while (mp_cmp_mag(&t1, &t2) == MP_GT);
@@ -252,7 +252,7 @@ int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d)
             goto LBL_Y;
          }
 
-         q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1UL) & MP_MASK;
+         q.dp[(i - t) - 1] = (q.dp[(i - t) - 1] - 1uL) & MP_MASK;
       }
    }
 
diff --git a/libtommath/bn_mp_div_2.c b/libtommath/bn_mp_div_2.c
index edc8982..2907a1b 100644
--- a/libtommath/bn_mp_div_2.c
+++ b/libtommath/bn_mp_div_2.c
@@ -42,7 +42,7 @@ int mp_div_2(const mp_int *a, mp_int *b)
       r = 0;
       for (x = b->used - 1; x >= 0; x--) {
          /* get the carry for the next iteration */
-         rr = *tmpa & 1;
+         rr = *tmpa & 1u;
 
          /* shift the current digit, add in carry and store */
          *tmpb-- = (*tmpa-- >> 1) | (r << (DIGIT_BIT - 1));
diff --git a/libtommath/bn_mp_div_2d.c b/libtommath/bn_mp_div_2d.c
index eae3498..aeaa8f2 100644
--- a/libtommath/bn_mp_div_2d.c
+++ b/libtommath/bn_mp_div_2d.c
@@ -44,20 +44,20 @@ int mp_div_2d(const mp_int *a, int b, mp_int *c, mp_int *d)
    }
 
    /* shift by as many digits in the bit count */
-   if (b >= (int)DIGIT_BIT) {
+   if (b >= DIGIT_BIT) {
       mp_rshd(c, b / DIGIT_BIT);
    }
 
    /* shift any bit count < DIGIT_BIT */
    D = (mp_digit)(b % DIGIT_BIT);
-   if (D != 0) {
+   if (D != 0u) {
       mp_digit *tmpc, mask, shift;
 
       /* mask */
-      mask = (((mp_digit)1) << D) - 1;
+      mask = ((mp_digit)1 << D) - 1uL;
 
       /* shift for lsb */
-      shift = DIGIT_BIT - D;
+      shift = (mp_digit)DIGIT_BIT - D;
 
       /* alias */
       tmpc = c->dp + (c->used - 1);
diff --git a/libtommath/bn_mp_div_3.c b/libtommath/bn_mp_div_3.c
index 9cc8caa..9d41793 100644
--- a/libtommath/bn_mp_div_3.c
+++ b/libtommath/bn_mp_div_3.c
@@ -24,7 +24,7 @@ int mp_div_3(const mp_int *a, mp_int *c, mp_digit *d)
    int      res, ix;
 
    /* b = 2**DIGIT_BIT / 3 */
-   b = (((mp_word)1) << ((mp_word)DIGIT_BIT)) / ((mp_word)3);
+   b = ((mp_word)1 << (mp_word)DIGIT_BIT) / (mp_word)3;
 
    if ((res = mp_init_size(&q, a->used)) != MP_OKAY) {
       return res;
@@ -34,11 +34,11 @@ int mp_div_3(const mp_int *a, mp_int *c, mp_digit *d)
    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]);
+      w = (w << (mp_word)DIGIT_BIT) | (mp_word)a->dp[ix];
 
-      if (w >= 3) {
+      if (w >= 3u) {
          /* multiply w by [1/3] */
-         t = (w * ((mp_word)b)) >> ((mp_word)DIGIT_BIT);
+         t = (w * (mp_word)b) >> (mp_word)DIGIT_BIT;
 
          /* now subtract 3 * [w/3] from w, to get the remainder */
          w -= t+t+t;
@@ -46,9 +46,9 @@ int mp_div_3(const mp_int *a, mp_int *c, mp_digit *d)
          /* fixup the remainder as required since
           * the optimization is not exact.
           */
-         while (w >= 3) {
-            t += 1;
-            w -= 3;
+         while (w >= 3u) {
+            t += 1u;
+            w -= 3u;
          }
       } else {
          t = 0;
diff --git a/libtommath/bn_mp_div_d.c b/libtommath/bn_mp_div_d.c
index db4a0a2..2124bcc 100644
--- a/libtommath/bn_mp_div_d.c
+++ b/libtommath/bn_mp_div_d.c
@@ -20,12 +20,12 @@ static int s_is_power_of_two(mp_digit b, int *p)
    int x;
 
    /* fast return if no power of two */
-   if ((b == 0) || ((b & (b-1)) != 0)) {
+   if ((b == 0u) || ((b & (b-1u)) != 0u)) {
       return 0;
    }
 
    for (x = 0; x < DIGIT_BIT; x++) {
-      if (b == (((mp_digit)1)<<x)) {
+      if (b == ((mp_digit)1<<(mp_digit)x)) {
          *p = x;
          return 1;
       }
@@ -42,12 +42,12 @@ int mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
    int     res, ix;
 
    /* cannot divide by zero */
-   if (b == 0) {
+   if (b == 0u) {
       return MP_VAL;
    }
 
    /* quick outs */
-   if ((b == 1) || (mp_iszero(a) == MP_YES)) {
+   if ((b == 1u) || (mp_iszero(a) == MP_YES)) {
       if (d != NULL) {
          *d = 0;
       }
@@ -60,7 +60,7 @@ int mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
    /* power of two ? */
    if (s_is_power_of_two(b, &ix) == 1) {
       if (d != NULL) {
-         *d = a->dp[0] & ((((mp_digit)1)<<ix) - 1);
+         *d = a->dp[0] & (((mp_digit)1<<(mp_digit)ix) - 1uL);
       }
       if (c != NULL) {
          return mp_div_2d(a, ix, c, NULL);
@@ -70,7 +70,7 @@ int mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
 
 #ifdef BN_MP_DIV_3_C
    /* three? */
-   if (b == 3) {
+   if (b == 3u) {
       return mp_div_3(a, c, d);
    }
 #endif
@@ -84,15 +84,15 @@ int mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
    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]);
+      w = (w << (mp_word)DIGIT_BIT) | (mp_word)a->dp[ix];
 
       if (w >= b) {
          t = (mp_digit)(w / b);
-         w -= ((mp_word)t) * ((mp_word)b);
+         w -= (mp_word)t * (mp_word)b;
       } else {
          t = 0;
       }
-      q.dp[ix] = (mp_digit)t;
+      q.dp[ix] = t;
    }
 
    if (d != NULL) {
diff --git a/libtommath/bn_mp_dr_reduce.c b/libtommath/bn_mp_dr_reduce.c
index 1ccb669..d677b03 100644
--- a/libtommath/bn_mp_dr_reduce.c
+++ b/libtommath/bn_mp_dr_reduce.c
@@ -61,7 +61,7 @@ top:
 
    /* compute (x mod B**m) + k * [x/B**m] inline and inplace */
    for (i = 0; i < m; i++) {
-      r         = (((mp_word)*tmpx2++) * (mp_word)k) + *tmpx1 + mu;
+      r         = ((mp_word)*tmpx2++ * (mp_word)k) + *tmpx1 + mu;
       *tmpx1++  = (mp_digit)(r & MP_MASK);
       mu        = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
    }
diff --git a/libtommath/bn_mp_dr_setup.c b/libtommath/bn_mp_dr_setup.c
index af0e213..32aa582 100644
--- a/libtommath/bn_mp_dr_setup.c
+++ b/libtommath/bn_mp_dr_setup.c
@@ -21,7 +21,7 @@ void mp_dr_setup(const 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]);
 }
 
 #endif
diff --git a/libtommath/bn_mp_export.c b/libtommath/bn_mp_export.c
index 4276f4f..92a85d5 100644
--- a/libtommath/bn_mp_export.c
+++ b/libtommath/bn_mp_export.c
@@ -38,33 +38,33 @@ int mp_export(void *rop, size_t *countp, int order, size_t size,
       } lint;
       lint.i = 0x01020304;
 
-      endian = (lint.c[0] == 4) ? -1 : 1;
+      endian = (lint.c[0] == '\x04') ? -1 : 1;
    }
 
-   odd_nails = (nails % 8);
+   odd_nails = (nails % 8u);
    odd_nail_mask = 0xff;
    for (i = 0; i < odd_nails; ++i) {
-      odd_nail_mask ^= (1 << (7 - i));
+      odd_nail_mask ^= (unsigned char)(1u << (7u - i));
    }
-   nail_bytes = nails / 8;
+   nail_bytes = nails / 8u;
 
-   bits = mp_count_bits(&t);
-   count = (bits / ((size * 8) - nails)) + (((bits % ((size * 8) - nails)) != 0) ? 1 : 0);
+   bits = (size_t)mp_count_bits(&t);
+   count = (bits / ((size * 8u) - nails)) + (((bits % ((size * 8u) - nails)) != 0u) ? 1u : 0u);
 
    for (i = 0; i < count; ++i) {
       for (j = 0; j < size; ++j) {
          unsigned char *byte = (unsigned char *)rop +
-                               (((order == -1) ? i : ((count - 1) - i)) * size) +
-                               ((endian == -1) ? j : ((size - 1) - j));
+                               (((order == -1) ? i : ((count - 1u) - i)) * size) +
+                               ((endian == -1) ? j : ((size - 1u) - j));
 
          if (j >= (size - nail_bytes)) {
             *byte = 0;
             continue;
          }
 
-         *byte = (unsigned char)((j == ((size - nail_bytes) - 1)) ? (t.dp[0] & odd_nail_mask) : (t.dp[0] & 0xFF));
+         *byte = (unsigned char)((j == ((size - nail_bytes) - 1u)) ? (t.dp[0] & odd_nail_mask) : (t.dp[0] & 0xFFuL));
 
-         if ((result = mp_div_2d(&t, ((j == ((size - nail_bytes) - 1)) ? (8 - odd_nails) : 8), &t, NULL)) != MP_OKAY) {
+         if ((result = mp_div_2d(&t, (j == ((size - nail_bytes) - 1u)) ? (int)(8u - odd_nails) : 8, &t, NULL)) != MP_OKAY) {
             mp_clear(&t);
             return result;
          }
diff --git a/libtommath/bn_mp_expt_d_ex.c b/libtommath/bn_mp_expt_d_ex.c
index 99319a5..d363d59 100644
--- a/libtommath/bn_mp_expt_d_ex.c
+++ b/libtommath/bn_mp_expt_d_ex.c
@@ -28,12 +28,12 @@ int mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
    }
 
    /* set initial result */
-   mp_set(c, 1);
+   mp_set(c, 1uL);
 
    if (fast != 0) {
-      while (b > 0) {
+      while (b > 0u) {
          /* if the bit is set multiply */
-         if ((b & 1) != 0) {
+         if ((b & 1u) != 0u) {
             if ((res = mp_mul(c, &g, c)) != MP_OKAY) {
                mp_clear(&g);
                return res;
@@ -41,7 +41,7 @@ int mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
          }
 
          /* square */
-         if (b > 1) {
+         if (b > 1u) {
             if ((res = mp_sqr(&g, &g)) != MP_OKAY) {
                mp_clear(&g);
                return res;
@@ -52,7 +52,7 @@ int mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
          b >>= 1;
       }
    } else {
-      for (x = 0; x < DIGIT_BIT; x++) {
+      for (x = 0; x < (unsigned)DIGIT_BIT; x++) {
          /* square */
          if ((res = mp_sqr(c, c)) != MP_OKAY) {
             mp_clear(&g);
@@ -60,7 +60,7 @@ int mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
          }
 
          /* if the bit is set multiply */
-         if ((b & (mp_digit)(((mp_digit)1) << (DIGIT_BIT - 1))) != 0) {
+         if ((b & ((mp_digit)1 << (DIGIT_BIT - 1))) != 0u) {
             if ((res = mp_mul(c, &g, c)) != MP_OKAY) {
                mp_clear(&g);
                return res;
diff --git a/libtommath/bn_mp_exptmod_fast.c b/libtommath/bn_mp_exptmod_fast.c
index 4a188d0..52d4a55 100644
--- a/libtommath/bn_mp_exptmod_fast.c
+++ b/libtommath/bn_mp_exptmod_fast.c
@@ -39,7 +39,7 @@ int mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y
     * one of many reduction algorithms without modding the guts of
     * the code with if statements everywhere.
     */
-   int (*redux)(mp_int *,const mp_int *,mp_digit);
+   int (*redux)(mp_int *x, const mp_int *n, mp_digit rho);
 
    /* find window size */
    x = mp_count_bits(X);
@@ -96,7 +96,7 @@ int mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y
 
       /* automatically pick the comba one if available (saves quite a few calls/ifs) */
 #ifdef BN_FAST_MP_MONTGOMERY_REDUCE_C
-      if ((((P->used * 2) + 1) < MP_WARRAY) &&
+      if ((((P->used * 2) + 1) < (int)MP_WARRAY) &&
           (P->used < (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
          redux = fast_mp_montgomery_reduce;
       } else
@@ -160,7 +160,7 @@ int mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y
       goto LBL_RES;
 #endif
    } else {
-      mp_set(&res, 1);
+      mp_set(&res, 1uL);
       if ((err = mp_mod(G, P, &M[1])) != MP_OKAY) {
          goto LBL_RES;
       }
diff --git a/libtommath/bn_mp_exteuclid.c b/libtommath/bn_mp_exteuclid.c
index 08e5ff2..29bad83 100644
--- a/libtommath/bn_mp_exteuclid.c
+++ b/libtommath/bn_mp_exteuclid.c
@@ -28,76 +28,76 @@ int mp_exteuclid(const mp_int *a, const mp_int *b, mp_int *U1, mp_int *U2, mp_in
    }
 
    /* initialize, (u1,u2,u3) = (1,0,a) */
-   mp_set(&u1, 1);
-   if ((err = mp_copy(a, &u3)) != MP_OKAY)                                        {
+   mp_set(&u1, 1uL);
+   if ((err = mp_copy(a, &u3)) != MP_OKAY) {
       goto LBL_ERR;
    }
 
    /* initialize, (v1,v2,v3) = (0,1,b) */
-   mp_set(&v2, 1);
-   if ((err = mp_copy(b, &v3)) != MP_OKAY)                                        {
+   mp_set(&v2, 1uL);
+   if ((err = mp_copy(b, &v3)) != MP_OKAY) {
       goto LBL_ERR;
    }
 
    /* loop while v3 != 0 */
    while (mp_iszero(&v3) == MP_NO) {
       /* q = u3/v3 */
-      if ((err = mp_div(&u3, &v3, &q, NULL)) != MP_OKAY)                         {
+      if ((err = mp_div(&u3, &v3, &q, NULL)) != MP_OKAY) {
          goto LBL_ERR;
       }
 
       /* (t1,t2,t3) = (u1,u2,u3) - (v1,v2,v3)q */
-      if ((err = mp_mul(&v1, &q, &tmp)) != MP_OKAY)                              {
+      if ((err = mp_mul(&v1, &q, &tmp)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_sub(&u1, &tmp, &t1)) != MP_OKAY)                             {
+      if ((err = mp_sub(&u1, &tmp, &t1)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_mul(&v2, &q, &tmp)) != MP_OKAY)                              {
+      if ((err = mp_mul(&v2, &q, &tmp)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_sub(&u2, &tmp, &t2)) != MP_OKAY)                             {
+      if ((err = mp_sub(&u2, &tmp, &t2)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_mul(&v3, &q, &tmp)) != MP_OKAY)                              {
+      if ((err = mp_mul(&v3, &q, &tmp)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_sub(&u3, &tmp, &t3)) != MP_OKAY)                             {
+      if ((err = mp_sub(&u3, &tmp, &t3)) != MP_OKAY) {
          goto LBL_ERR;
       }
 
       /* (u1,u2,u3) = (v1,v2,v3) */
-      if ((err = mp_copy(&v1, &u1)) != MP_OKAY)                                  {
+      if ((err = mp_copy(&v1, &u1)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_copy(&v2, &u2)) != MP_OKAY)                                  {
+      if ((err = mp_copy(&v2, &u2)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_copy(&v3, &u3)) != MP_OKAY)                                  {
+      if ((err = mp_copy(&v3, &u3)) != MP_OKAY) {
          goto LBL_ERR;
       }
 
       /* (v1,v2,v3) = (t1,t2,t3) */
-      if ((err = mp_copy(&t1, &v1)) != MP_OKAY)                                  {
+      if ((err = mp_copy(&t1, &v1)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_copy(&t2, &v2)) != MP_OKAY)                                  {
+      if ((err = mp_copy(&t2, &v2)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_copy(&t3, &v3)) != MP_OKAY)                                  {
+      if ((err = mp_copy(&t3, &v3)) != MP_OKAY) {
          goto LBL_ERR;
       }
    }
 
    /* make sure U3 >= 0 */
    if (u3.sign == MP_NEG) {
-      if ((err = mp_neg(&u1, &u1)) != MP_OKAY)                                   {
+      if ((err = mp_neg(&u1, &u1)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_neg(&u2, &u2)) != MP_OKAY)                                   {
+      if ((err = mp_neg(&u2, &u2)) != MP_OKAY) {
          goto LBL_ERR;
       }
-      if ((err = mp_neg(&u3, &u3)) != MP_OKAY)                                   {
+      if ((err = mp_neg(&u3, &u3)) != MP_OKAY) {
          goto LBL_ERR;
       }
    }
diff --git a/libtommath/bn_mp_fread.c b/libtommath/bn_mp_fread.c
index d0de595..6922183 100644
--- a/libtommath/bn_mp_fread.c
+++ b/libtommath/bn_mp_fread.c
@@ -20,13 +20,14 @@
 int mp_fread(mp_int *a, int radix, FILE *stream)
 {
    int err, ch, neg, y;
+   unsigned pos;
 
    /* clear a */
    mp_zero(a);
 
    /* if first digit is - then set negative */
    ch = fgetc(stream);
-   if (ch == '-') {
+   if (ch == (int)'-') {
       neg = MP_NEG;
       ch = fgetc(stream);
    } else {
@@ -34,27 +35,28 @@ int mp_fread(mp_int *a, int radix, FILE *stream)
    }
 
    for (;;) {
-      /* find y in the radix map */
-      for (y = 0; y < radix; y++) {
-         if (mp_s_rmap[y] == ch) {
-            break;
-         }
+      pos = (unsigned)(ch - (int)'(');
+      if (mp_s_rmap_reverse_sz < pos) {
+         break;
       }
-      if (y == radix) {
+
+      y = (int)mp_s_rmap_reverse[pos];
+
+      if ((y == 0xff) || (y >= radix)) {
          break;
       }
 
       /* shift up and add */
-      if ((err = mp_mul_d(a, radix, a)) != MP_OKAY) {
+      if ((err = mp_mul_d(a, (mp_digit)radix, a)) != MP_OKAY) {
          return err;
       }
-      if ((err = mp_add_d(a, y, a)) != MP_OKAY) {
+      if ((err = mp_add_d(a, (mp_digit)y, a)) != MP_OKAY) {
          return err;
       }
 
       ch = fgetc(stream);
    }
-   if (mp_cmp_d(a, 0) != MP_EQ) {
+   if (mp_cmp_d(a, 0uL) != MP_EQ) {
       a->sign = neg;
    }
 
diff --git a/libtommath/bn_mp_fwrite.c b/libtommath/bn_mp_fwrite.c
index 829dd4a..8541bc7 100644
--- a/libtommath/bn_mp_fwrite.c
+++ b/libtommath/bn_mp_fwrite.c
@@ -25,7 +25,7 @@ int mp_fwrite(const mp_int *a, int radix, FILE *stream)
       return err;
    }
 
-   buf = OPT_CAST(char) XMALLOC(len);
+   buf = OPT_CAST(char) XMALLOC((size_t)len);
    if (buf == NULL) {
       return MP_MEM;
    }
@@ -36,7 +36,7 @@ int mp_fwrite(const mp_int *a, int radix, FILE *stream)
    }
 
    for (x = 0; x < len; x++) {
-      if (fputc(buf[x], stream) == EOF) {
+      if (fputc((int)buf[x], stream) == EOF) {
          XFREE(buf);
          return MP_VAL;
       }
diff --git a/libtommath/bn_mp_get_int.c b/libtommath/bn_mp_get_int.c
index f4a347f..d99a0a0 100644
--- a/libtommath/bn_mp_get_int.c
+++ b/libtommath/bn_mp_get_int.c
@@ -26,7 +26,7 @@ unsigned long mp_get_int(const mp_int *a)
    }
 
    /* get number of digits of the lsb we have to read */
-   i = MIN(a->used, (int)(((sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
+   i = MIN(a->used, ((((int)sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
 
    /* get most significant digit of result */
    res = DIGIT(a, i);
diff --git a/libtommath/bn_mp_get_long.c b/libtommath/bn_mp_get_long.c
index 3fc7c35..9ec2664 100644
--- a/libtommath/bn_mp_get_long.c
+++ b/libtommath/bn_mp_get_long.c
@@ -26,7 +26,7 @@ unsigned long mp_get_long(const mp_int *a)
    }
 
    /* get number of digits of the lsb we have to read */
-   i = MIN(a->used, (int)(((sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
+   i = MIN(a->used, ((((int)sizeof(unsigned long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
 
    /* get most significant digit of result */
    res = DIGIT(a, i);
diff --git a/libtommath/bn_mp_get_long_long.c b/libtommath/bn_mp_get_long_long.c
index 838c3c3..ffde373 100644
--- a/libtommath/bn_mp_get_long_long.c
+++ b/libtommath/bn_mp_get_long_long.c
@@ -26,7 +26,7 @@ unsigned long long mp_get_long_long(const mp_int *a)
    }
 
    /* get number of digits of the lsb we have to read */
-   i = MIN(a->used, (int)(((sizeof(unsigned long long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
+   i = MIN(a->used, ((((int)sizeof(unsigned long long) * CHAR_BIT) + DIGIT_BIT - 1) / DIGIT_BIT)) - 1;
 
    /* get most significant digit of result */
    res = DIGIT(a, i);
diff --git a/libtommath/bn_mp_grow.c b/libtommath/bn_mp_grow.c
index 0030931..60f8f32 100644
--- a/libtommath/bn_mp_grow.c
+++ b/libtommath/bn_mp_grow.c
@@ -32,7 +32,7 @@ int mp_grow(mp_int *a, int size)
        * in case the operation failed we don't want
        * to overwrite the dp member of a.
        */
-      tmp = OPT_CAST(mp_digit) XREALLOC(a->dp, sizeof(mp_digit) * size);
+      tmp = OPT_CAST(mp_digit) XREALLOC(a->dp, sizeof(mp_digit) * (size_t)size);
       if (tmp == NULL) {
          /* reallocation failed but "a" is still valid [can be freed] */
          return MP_MEM;
diff --git a/libtommath/bn_mp_import.c b/libtommath/bn_mp_import.c
index afd735e..9bbd215 100644
--- a/libtommath/bn_mp_import.c
+++ b/libtommath/bn_mp_import.c
@@ -34,27 +34,27 @@ int mp_import(mp_int *rop, size_t count, int order, size_t size,
       } lint;
       lint.i = 0x01020304;
 
-      endian = (lint.c[0] == 4) ? -1 : 1;
+      endian = (lint.c[0] == '\x04') ? -1 : 1;
    }
 
-   odd_nails = (nails % 8);
+   odd_nails = (nails % 8u);
    odd_nail_mask = 0xff;
    for (i = 0; i < odd_nails; ++i) {
-      odd_nail_mask ^= (1 << (7 - i));
+      odd_nail_mask ^= (unsigned char)(1u << (7u - i));
    }
-   nail_bytes = nails / 8;
+   nail_bytes = nails / 8u;
 
    for (i = 0; i < count; ++i) {
       for (j = 0; j < (size - nail_bytes); ++j) {
          unsigned char byte = *((unsigned char *)op +
-                                (((order == 1) ? i : ((count - 1) - i)) * size) +
-                                ((endian == 1) ? (j + nail_bytes) : (((size - 1) - j) - nail_bytes)));
+                                (((order == 1) ? i : ((count - 1u) - i)) * size) +
+                                ((endian == 1) ? (j + nail_bytes) : (((size - 1u) - j) - nail_bytes)));
 
-         if ((result = mp_mul_2d(rop, ((j == 0) ? (8 - odd_nails) : 8), rop)) != MP_OKAY) {
+         if ((result = mp_mul_2d(rop, (j == 0u) ? (int)(8u - odd_nails) : 8, rop)) != MP_OKAY) {
             return result;
          }
 
-         rop->dp[0] |= (j == 0) ? (byte & odd_nail_mask) : byte;
+         rop->dp[0] |= (j == 0u) ? (mp_digit)(byte & odd_nail_mask) : (mp_digit)byte;
          rop->used  += 1;
       }
    }
diff --git a/libtommath/bn_mp_init.c b/libtommath/bn_mp_init.c
index 0556aeb..ad630e3 100644
--- a/libtommath/bn_mp_init.c
+++ b/libtommath/bn_mp_init.c
@@ -21,7 +21,7 @@ int mp_init(mp_int *a)
    int i;
 
    /* allocate memory required and clear it */
-   a->dp = OPT_CAST(mp_digit) XMALLOC(sizeof(mp_digit) * MP_PREC);
+   a->dp = OPT_CAST(mp_digit) XMALLOC(sizeof(mp_digit) * (size_t)MP_PREC);
    if (a->dp == NULL) {
       return MP_MEM;
    }
diff --git a/libtommath/bn_mp_init_multi.c b/libtommath/bn_mp_init_multi.c
index 0da7803..9ed777c 100644
--- a/libtommath/bn_mp_init_multi.c
+++ b/libtommath/bn_mp_init_multi.c
@@ -14,6 +14,7 @@
  *
  * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
  */
+
 #include <stdarg.h>
 
 int mp_init_multi(mp_int *mp, ...)
diff --git a/libtommath/bn_mp_init_size.c b/libtommath/bn_mp_init_size.c
index 623a03f..35713ac 100644
--- a/libtommath/bn_mp_init_size.c
+++ b/libtommath/bn_mp_init_size.c
@@ -24,7 +24,7 @@ int mp_init_size(mp_int *a, int size)
    size += (MP_PREC * 2) - (size % MP_PREC);
 
    /* alloc mem */
-   a->dp = OPT_CAST(mp_digit) XMALLOC(sizeof(mp_digit) * size);
+   a->dp = OPT_CAST(mp_digit) XMALLOC(sizeof(mp_digit) * (size_t)size);
    if (a->dp == NULL) {
       return MP_MEM;
    }
diff --git a/libtommath/bn_mp_invmod.c b/libtommath/bn_mp_invmod.c
index 525493a..96717ea 100644
--- a/libtommath/bn_mp_invmod.c
+++ b/libtommath/bn_mp_invmod.c
@@ -18,14 +18,14 @@
 /* hac 14.61, pp608 */
 int mp_invmod(const mp_int *a, const mp_int *b, mp_int *c)
 {
-   /* b cannot be negative */
-   if ((b->sign == MP_NEG) || (mp_iszero(b) == MP_YES)) {
+   /* b cannot be negative and has to be >1 */
+   if ((b->sign == MP_NEG) || (mp_cmp_d(b, 1uL) != MP_GT)) {
       return MP_VAL;
    }
 
 #ifdef BN_FAST_MP_INVMOD_C
    /* if the modulus is odd we can use a faster routine instead */
-   if ((mp_isodd(b) == MP_YES) && (mp_cmp_d(b, 1) != MP_EQ)) {
+   if ((mp_isodd(b) == MP_YES)) {
       return fast_mp_invmod(a, b, c);
    }
 #endif
diff --git a/libtommath/bn_mp_invmod_slow.c b/libtommath/bn_mp_invmod_slow.c
index 2bb5196..360f161 100644
--- a/libtommath/bn_mp_invmod_slow.c
+++ b/libtommath/bn_mp_invmod_slow.c
@@ -53,8 +53,8 @@ int mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c)
    if ((res = mp_copy(&y, &v)) != MP_OKAY) {
       goto LBL_ERR;
    }
-   mp_set(&A, 1);
-   mp_set(&D, 1);
+   mp_set(&A, 1uL);
+   mp_set(&D, 1uL);
 
 top:
    /* 4.  while u is even do */
@@ -143,13 +143,13 @@ top:
    /* now a = C, b = D, gcd == g*v */
 
    /* if v != 1 then there is no inverse */
-   if (mp_cmp_d(&v, 1) != MP_EQ) {
+   if (mp_cmp_d(&v, 1uL) != MP_EQ) {
       res = MP_VAL;
       goto LBL_ERR;
    }
 
    /* if its too low */
-   while (mp_cmp_d(&C, 0) == MP_LT) {
+   while (mp_cmp_d(&C, 0uL) == MP_LT) {
       if ((res = mp_add(&C, b, &C)) != MP_OKAY) {
          goto LBL_ERR;
       }
diff --git a/libtommath/bn_mp_is_square.c b/libtommath/bn_mp_is_square.c
index dd5150e..329d727 100644
--- a/libtommath/bn_mp_is_square.c
+++ b/libtommath/bn_mp_is_square.c
@@ -58,15 +58,15 @@ int mp_is_square(const mp_int *arg, int *ret)
    }
 
    /* First check mod 128 (suppose that DIGIT_BIT is at least 7) */
-   if (rem_128[127 & DIGIT(arg, 0)] == 1) {
+   if (rem_128[127u & DIGIT(arg, 0)] == (char)1) {
       return MP_OKAY;
    }
 
    /* Next check mod 105 (3*5*7) */
-   if ((res = mp_mod_d(arg, 105, &c)) != MP_OKAY) {
+   if ((res = mp_mod_d(arg, 105uL, &c)) != MP_OKAY) {
       return res;
    }
-   if (rem_105[c] == 1) {
+   if (rem_105[c] == (char)1) {
       return MP_OKAY;
    }
 
@@ -82,13 +82,13 @@ int mp_is_square(const mp_int *arg, int *ret)
     * free "t" so the easiest way is to goto ERR.  We know that res
     * is already equal to MP_OKAY from the mp_mod call
     */
-   if (((1L<<(r%11)) & 0x5C4L) != 0L)       goto ERR;
-   if (((1L<<(r%13)) & 0x9E4L) != 0L)       goto ERR;
-   if (((1L<<(r%17)) & 0x5CE8L) != 0L)      goto ERR;
-   if (((1L<<(r%19)) & 0x4F50CL) != 0L)     goto ERR;
-   if (((1L<<(r%23)) & 0x7ACCA0L) != 0L)    goto ERR;
-   if (((1L<<(r%29)) & 0xC2EDD0CL) != 0L)   goto ERR;
-   if (((1L<<(r%31)) & 0x6DE2B848L) != 0L)  goto ERR;
+   if (((1uL<<(r%11uL)) & 0x5C4uL) != 0uL)         goto ERR;
+   if (((1uL<<(r%13uL)) & 0x9E4uL) != 0uL)         goto ERR;
+   if (((1uL<<(r%17uL)) & 0x5CE8uL) != 0uL)        goto ERR;
+   if (((1uL<<(r%19uL)) & 0x4F50CuL) != 0uL)       goto ERR;
+   if (((1uL<<(r%23uL)) & 0x7ACCA0uL) != 0uL)      goto ERR;
+   if (((1uL<<(r%29uL)) & 0xC2EDD0CuL) != 0uL)     goto ERR;
+   if (((1uL<<(r%31uL)) & 0x6DE2B848uL) != 0uL)    goto ERR;
 
    /* Final check - is sqr(sqrt(arg)) == arg ? */
    if ((res = mp_sqrt(arg, &t)) != MP_OKAY) {
diff --git a/libtommath/bn_mp_jacobi.c b/libtommath/bn_mp_jacobi.c
index c314c82..ef2e72f 100644
--- a/libtommath/bn_mp_jacobi.c
+++ b/libtommath/bn_mp_jacobi.c
@@ -32,14 +32,14 @@ int mp_jacobi(const mp_int *a, const mp_int *n, int *c)
    }
 
    /* if n <= 0 return MP_VAL */
-   if (mp_cmp_d(n, 0) != MP_GT) {
+   if (mp_cmp_d(n, 0uL) != MP_GT) {
       return MP_VAL;
    }
 
    /* step 1. handle case of a == 0 */
    if (mp_iszero(a) == MP_YES) {
       /* special case of a == 0 and n == 1 */
-      if (mp_cmp_d(n, 1) == MP_EQ) {
+      if (mp_cmp_d(n, 1uL) == MP_EQ) {
          *c = 1;
       } else {
          *c = 0;
@@ -48,7 +48,7 @@ int mp_jacobi(const mp_int *a, const mp_int *n, int *c)
    }
 
    /* step 2.  if a == 1, return 1 */
-   if (mp_cmp_d(a, 1) == MP_EQ) {
+   if (mp_cmp_d(a, 1uL) == MP_EQ) {
       *c = 1;
       return MP_OKAY;
    }
@@ -72,26 +72,26 @@ int mp_jacobi(const mp_int *a, const mp_int *n, int *c)
    }
 
    /* step 4.  if e is even set s=1 */
-   if ((k & 1) == 0) {
+   if (((unsigned)k & 1u) == 0u) {
       s = 1;
    } else {
       /* else set s=1 if p = 1/7 (mod 8) or s=-1 if p = 3/5 (mod 8) */
-      residue = n->dp[0] & 7;
+      residue = n->dp[0] & 7u;
 
-      if ((residue == 1) || (residue == 7)) {
+      if ((residue == 1u) || (residue == 7u)) {
          s = 1;
-      } else if ((residue == 3) || (residue == 5)) {
+      } else if ((residue == 3u) || (residue == 5u)) {
          s = -1;
       }
    }
 
    /* step 5.  if p == 3 (mod 4) *and* a1 == 3 (mod 4) then s = -s */
-   if (((n->dp[0] & 3) == 3) && ((a1.dp[0] & 3) == 3)) {
+   if (((n->dp[0] & 3u) == 3u) && ((a1.dp[0] & 3u) == 3u)) {
       s = -s;
    }
 
    /* if a1 == 1 we're done */
-   if (mp_cmp_d(&a1, 1) == MP_EQ) {
+   if (mp_cmp_d(&a1, 1uL) == MP_EQ) {
       *c = s;
    } else {
       /* n1 = n mod a1 */
diff --git a/libtommath/bn_mp_lshd.c b/libtommath/bn_mp_lshd.c
index 888989a..b49b545 100644
--- a/libtommath/bn_mp_lshd.c
+++ b/libtommath/bn_mp_lshd.c
@@ -24,6 +24,10 @@ int mp_lshd(mp_int *a, int b)
    if (b <= 0) {
       return MP_OKAY;
    }
+   /* no need to shift 0 around */
+   if (mp_iszero(a) == MP_YES) {
+      return MP_OKAY;
+   }
 
    /* grow to fit the new digits */
    if (a->alloc < (a->used + b)) {
diff --git a/libtommath/bn_mp_mod_2d.c b/libtommath/bn_mp_mod_2d.c
index 8e69757..7a74746 100644
--- a/libtommath/bn_mp_mod_2d.c
+++ b/libtommath/bn_mp_mod_2d.c
@@ -27,7 +27,7 @@ int mp_mod_2d(const mp_int *a, int b, mp_int *c)
    }
 
    /* if the modulus is larger than the value than return */
-   if (b >= (int)(a->used * DIGIT_BIT)) {
+   if (b >= (a->used * DIGIT_BIT)) {
       res = mp_copy(a, c);
       return res;
    }
@@ -43,7 +43,7 @@ int mp_mod_2d(const mp_int *a, int b, mp_int *c)
    }
    /* clear the digit that is not completely outside/inside the modulus */
    c->dp[b / DIGIT_BIT] &=
-      (mp_digit)((((mp_digit) 1) << (((mp_digit) b) % DIGIT_BIT)) - ((mp_digit) 1));
+      ((mp_digit)1 << (mp_digit)(b % DIGIT_BIT)) - (mp_digit)1;
    mp_clamp(c);
    return MP_OKAY;
 }
diff --git a/libtommath/bn_mp_montgomery_calc_normalization.c b/libtommath/bn_mp_montgomery_calc_normalization.c
index f2b0856..360e3e5 100644
--- a/libtommath/bn_mp_montgomery_calc_normalization.c
+++ b/libtommath/bn_mp_montgomery_calc_normalization.c
@@ -33,7 +33,7 @@ int mp_montgomery_calc_normalization(mp_int *a, const mp_int *b)
          return res;
       }
    } else {
-      mp_set(a, 1);
+      mp_set(a, 1uL);
       bits = 1;
    }
 
diff --git a/libtommath/bn_mp_montgomery_reduce.c b/libtommath/bn_mp_montgomery_reduce.c
index a38173e..e3a0eaa 100644
--- a/libtommath/bn_mp_montgomery_reduce.c
+++ b/libtommath/bn_mp_montgomery_reduce.c
@@ -28,9 +28,10 @@ int mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
     * are fixed up in the inner loop.
     */
    digs = (n->used * 2) + 1;
-   if ((digs < MP_WARRAY) &&
+   if ((digs < (int)MP_WARRAY) &&
+       (x->used <= (int)MP_WARRAY) &&
        (n->used <
-        (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
+        (int)(1u << (((size_t)CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)DIGIT_BIT))))) {
       return fast_mp_montgomery_reduce(x, n, rho);
    }
 
@@ -72,19 +73,19 @@ int mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho)
          for (iy = 0; iy < n->used; iy++) {
             /* compute product and sum */
             r       = ((mp_word)mu * (mp_word)*tmpn++) +
-                      (mp_word) u + (mp_word) *tmpx;
+                      (mp_word)u + (mp_word)*tmpx;
 
             /* get carry */
-            u       = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+            u       = (mp_digit)(r >> (mp_word)DIGIT_BIT);
 
             /* fix digit */
-            *tmpx++ = (mp_digit)(r & ((mp_word) MP_MASK));
+            *tmpx++ = (mp_digit)(r & (mp_word)MP_MASK);
          }
          /* At this point the ix'th digit of x should be zero */
 
 
          /* propagate carries upwards as required*/
-         while (u != 0) {
+         while (u != 0u) {
             *tmpx   += u;
             u        = *tmpx >> DIGIT_BIT;
             *tmpx++ &= MP_MASK;
diff --git a/libtommath/bn_mp_montgomery_setup.c b/libtommath/bn_mp_montgomery_setup.c
index 685ba51..75da42b 100644
--- a/libtommath/bn_mp_montgomery_setup.c
+++ b/libtommath/bn_mp_montgomery_setup.c
@@ -30,24 +30,24 @@ int mp_montgomery_setup(const mp_int *n, mp_digit *rho)
     */
    b = n->dp[0];
 
-   if ((b & 1) == 0) {
+   if ((b & 1u) == 0u) {
       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 + 2u) & 4u) << 1) + b; /* here x*a==1 mod 2**4 */
+   x *= 2u - (b * x);              /* here x*a==1 mod 2**8 */
 #if !defined(MP_8BIT)
-   x *= 2 - (b * x);             /* here x*a==1 mod 2**16 */
+   x *= 2u - (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 *= 2u - (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 *= 2u - (b * x);              /* here x*a==1 mod 2**64 */
 #endif
 
    /* rho = -1/m mod b */
-   *rho = (mp_digit)(((mp_word)1 << ((mp_word) DIGIT_BIT)) - x) & MP_MASK;
+   *rho = (mp_digit)(((mp_word)1 << (mp_word)DIGIT_BIT) - x) & MP_MASK;
 
    return MP_OKAY;
 }
diff --git a/libtommath/bn_mp_mul.c b/libtommath/bn_mp_mul.c
index 71d523d..babb12b 100644
--- a/libtommath/bn_mp_mul.c
+++ b/libtommath/bn_mp_mul.c
@@ -43,9 +43,9 @@ int mp_mul(const mp_int *a, const mp_int *b, mp_int *c)
          int     digs = a->used + b->used + 1;
 
 #ifdef BN_FAST_S_MP_MUL_DIGS_C
-         if ((digs < MP_WARRAY) &&
+         if ((digs < (int)MP_WARRAY) &&
              (MIN(a->used, b->used) <=
-              (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
+              (int)(1u << (((size_t)CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)DIGIT_BIT))))) {
             res = fast_s_mp_mul_digs(a, b, c, digs);
          } else
 #endif
diff --git a/libtommath/bn_mp_mul_2.c b/libtommath/bn_mp_mul_2.c
index 1744681..7611536 100644
--- a/libtommath/bn_mp_mul_2.c
+++ b/libtommath/bn_mp_mul_2.c
@@ -46,10 +46,10 @@ int mp_mul_2(const mp_int *a, mp_int *b)
          /* get what will be the *next* carry bit from the
           * MSB of the current digit
           */
-         rr = *tmpa >> ((mp_digit)(DIGIT_BIT - 1));
+         rr = *tmpa >> (mp_digit)(DIGIT_BIT - 1);
 
          /* now shift up this digit, add in the carry [from the previous] */
-         *tmpb++ = ((*tmpa++ << ((mp_digit)1)) | r) & MP_MASK;
+         *tmpb++ = ((*tmpa++ << 1uL) | r) & MP_MASK;
 
          /* copy the carry that would be from the source
           * digit into the next iteration
@@ -58,7 +58,7 @@ int mp_mul_2(const mp_int *a, mp_int *b)
       }
 
       /* new leading digit? */
-      if (r != 0) {
+      if (r != 0u) {
          /* add a MSB which is always 1 at this point */
          *tmpb = 1;
          ++(b->used);
diff --git a/libtommath/bn_mp_mul_2d.c b/libtommath/bn_mp_mul_2d.c
index 4938e57..96aef85 100644
--- a/libtommath/bn_mp_mul_2d.c
+++ b/libtommath/bn_mp_mul_2d.c
@@ -28,14 +28,14 @@ int mp_mul_2d(const mp_int *a, int b, mp_int *c)
       }
    }
 
-   if (c->alloc < (int)(c->used + (b / DIGIT_BIT) + 1)) {
+   if (c->alloc < (c->used + (b / DIGIT_BIT) + 1)) {
       if ((res = mp_grow(c, c->used + (b / DIGIT_BIT) + 1)) != MP_OKAY) {
          return res;
       }
    }
 
    /* shift by as many digits in the bit count */
-   if (b >= (int)DIGIT_BIT) {
+   if (b >= DIGIT_BIT) {
       if ((res = mp_lshd(c, b / DIGIT_BIT)) != MP_OKAY) {
          return res;
       }
@@ -43,15 +43,15 @@ int mp_mul_2d(const mp_int *a, int b, mp_int *c)
 
    /* shift any bit count < DIGIT_BIT */
    d = (mp_digit)(b % DIGIT_BIT);
-   if (d != 0) {
+   if (d != 0u) {
       mp_digit *tmpc, shift, mask, r, rr;
       int x;
 
       /* bitmask for carries */
-      mask = (((mp_digit)1) << d) - 1;
+      mask = ((mp_digit)1 << d) - (mp_digit)1;
 
       /* shift for msbs */
-      shift = DIGIT_BIT - d;
+      shift = (mp_digit)DIGIT_BIT - d;
 
       /* alias */
       tmpc = c->dp;
@@ -71,7 +71,7 @@ int mp_mul_2d(const mp_int *a, int b, mp_int *c)
       }
 
       /* set final carry */
-      if (r != 0) {
+      if (r != 0u) {
          c->dp[(c->used)++] = r;
       }
    }
diff --git a/libtommath/bn_mp_mul_d.c b/libtommath/bn_mp_mul_d.c
index 0f6d03e..13f94a2 100644
--- a/libtommath/bn_mp_mul_d.c
+++ b/libtommath/bn_mp_mul_d.c
@@ -50,10 +50,10 @@ int mp_mul_d(const mp_int *a, mp_digit b, mp_int *c)
       r       = (mp_word)u + ((mp_word)*tmpa++ * (mp_word)b);
 
       /* mask off higher bits to get a single digit */
-      *tmpc++ = (mp_digit)(r & ((mp_word)MP_MASK));
+      *tmpc++ = (mp_digit)(r & (mp_word)MP_MASK);
 
       /* send carry into next iteration */
-      u       = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
+      u       = (mp_digit)(r >> (mp_word)DIGIT_BIT);
    }
 
    /* store final carry [if any] and increment ix offset  */
diff --git a/libtommath/bn_mp_n_root_ex.c b/libtommath/bn_mp_n_root_ex.c
index ca50649..60c9929 100644
--- a/libtommath/bn_mp_n_root_ex.c
+++ b/libtommath/bn_mp_n_root_ex.c
@@ -31,7 +31,7 @@ int mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
    int     res;
 
    /* input must be positive if b is even */
-   if (((b & 1) == 0) && (a->sign == MP_NEG)) {
+   if (((b & 1u) == 0u) && (a->sign == MP_NEG)) {
       return MP_VAL;
    }
 
@@ -52,7 +52,7 @@ int mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
    a_.sign = MP_ZPOS;
 
    /* t2 = 2 */
-   mp_set(&t2, 2);
+   mp_set(&t2, 2uL);
 
    do {
       /* t1 = t2 */
@@ -63,7 +63,7 @@ int mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
       /* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */
 
       /* t3 = t1**(b-1) */
-      if ((res = mp_expt_d_ex(&t1, b - 1, &t3, fast)) != MP_OKAY) {
+      if ((res = mp_expt_d_ex(&t1, b - 1u, &t3, fast)) != MP_OKAY) {
          goto LBL_T3;
       }
 
@@ -101,7 +101,7 @@ int mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
       }
 
       if (mp_cmp(&t2, &a_) == MP_GT) {
-         if ((res = mp_sub_d(&t1, 1, &t1)) != MP_OKAY) {
+         if ((res = mp_sub_d(&t1, 1uL, &t1)) != MP_OKAY) {
             goto LBL_T3;
          }
       } else {
diff --git a/libtommath/bn_mp_prime_fermat.c b/libtommath/bn_mp_prime_fermat.c
index 9c15435..e71e0ae 100644
--- a/libtommath/bn_mp_prime_fermat.c
+++ b/libtommath/bn_mp_prime_fermat.c
@@ -32,7 +32,7 @@ int mp_prime_fermat(const mp_int *a, const mp_int *b, int *result)
    *result = MP_NO;
 
    /* ensure b > 1 */
-   if (mp_cmp_d(b, 1) != MP_GT) {
+   if (mp_cmp_d(b, 1uL) != MP_GT) {
       return MP_VAL;
    }
 
diff --git a/libtommath/bn_mp_prime_is_divisible.c b/libtommath/bn_mp_prime_is_divisible.c
index c1e1158..c49fdd2 100644
--- a/libtommath/bn_mp_prime_is_divisible.c
+++ b/libtommath/bn_mp_prime_is_divisible.c
@@ -35,7 +35,7 @@ int mp_prime_is_divisible(const mp_int *a, int *result)
       }
 
       /* is the residue zero? */
-      if (res == 0) {
+      if (res == 0u) {
          *result = MP_YES;
          return MP_OKAY;
       }
diff --git a/libtommath/bn_mp_prime_miller_rabin.c b/libtommath/bn_mp_prime_miller_rabin.c
index 5de5f05..34c4d1c 100644
--- a/libtommath/bn_mp_prime_miller_rabin.c
+++ b/libtommath/bn_mp_prime_miller_rabin.c
@@ -31,7 +31,7 @@ int mp_prime_miller_rabin(const mp_int *a, const mp_int *b, int *result)
    *result = MP_NO;
 
    /* ensure b > 1 */
-   if (mp_cmp_d(b, 1) != MP_GT) {
+   if (mp_cmp_d(b, 1uL) != MP_GT) {
       return MP_VAL;
    }
 
@@ -39,7 +39,7 @@ int mp_prime_miller_rabin(const mp_int *a, const mp_int *b, int *result)
    if ((err = mp_init_copy(&n1, a)) != MP_OKAY) {
       return err;
    }
-   if ((err = mp_sub_d(&n1, 1, &n1)) != MP_OKAY) {
+   if ((err = mp_sub_d(&n1, 1uL, &n1)) != MP_OKAY) {
       goto LBL_N1;
    }
 
@@ -67,7 +67,7 @@ int mp_prime_miller_rabin(const mp_int *a, const mp_int *b, int *result)
    }
 
    /* if y != 1 and y != n1 do */
-   if ((mp_cmp_d(&y, 1) != MP_EQ) && (mp_cmp(&y, &n1) != MP_EQ)) {
+   if ((mp_cmp_d(&y, 1uL) != MP_EQ) && (mp_cmp(&y, &n1) != MP_EQ)) {
       j = 1;
       /* while j <= s-1 and y != n1 */
       while ((j <= (s - 1)) && (mp_cmp(&y, &n1) != MP_EQ)) {
@@ -76,7 +76,7 @@ int mp_prime_miller_rabin(const mp_int *a, const mp_int *b, int *result)
          }
 
          /* if y == 1 then composite */
-         if (mp_cmp_d(&y, 1) == MP_EQ) {
+         if (mp_cmp_d(&y, 1uL) == MP_EQ) {
             goto LBL_Y;
          }
 
diff --git a/libtommath/bn_mp_prime_next_prime.c b/libtommath/bn_mp_prime_next_prime.c
index f383cbb..b106a74 100644
--- a/libtommath/bn_mp_prime_next_prime.c
+++ b/libtommath/bn_mp_prime_next_prime.c
@@ -46,10 +46,10 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
                 * however, the prime must be
                 * congruent to 3 mod 4
                 */
-               if ((ltm_prime_tab[x + 1] & 3) != 3) {
+               if ((ltm_prime_tab[x + 1] & 3u) != 3u) {
                   /* scan upwards for a prime congruent to 3 mod 4 */
                   for (y = x + 1; y < PRIME_SIZE; y++) {
-                     if ((ltm_prime_tab[y] & 3) == 3) {
+                     if ((ltm_prime_tab[y] & 3u) == 3u) {
                         mp_set(a, ltm_prime_tab[y]);
                         return MP_OKAY;
                      }
@@ -62,8 +62,8 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
          }
       }
       /* at this point a maybe 1 */
-      if (mp_cmp_d(a, 1) == MP_EQ) {
-         mp_set(a, 2);
+      if (mp_cmp_d(a, 1uL) == MP_EQ) {
+         mp_set(a, 2uL);
          return MP_OKAY;
       }
       /* fall through to the sieve */
@@ -80,15 +80,15 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
 
    if (bbs_style == 1) {
       /* if a mod 4 != 3 subtract the correct value to make it so */
-      if ((a->dp[0] & 3) != 3) {
-         if ((err = mp_sub_d(a, (a->dp[0] & 3) + 1, a)) != MP_OKAY) {
+      if ((a->dp[0] & 3u) != 3u) {
+         if ((err = mp_sub_d(a, (a->dp[0] & 3u) + 1u, a)) != MP_OKAY) {
             return err;
          };
       }
    } else {
       if (mp_iseven(a) == MP_YES) {
          /* force odd */
-         if ((err = mp_sub_d(a, 1, a)) != MP_OKAY) {
+         if ((err = mp_sub_d(a, 1uL, a)) != MP_OKAY) {
             return err;
          }
       }
@@ -127,11 +127,11 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
             }
 
             /* set flag if zero */
-            if (res_tab[x] == 0) {
+            if (res_tab[x] == 0u) {
                y = 1;
             }
          }
-      } while ((y == 1) && (step < ((((mp_digit)1) << DIGIT_BIT) - kstep)));
+      } while ((y == 1) && (step < (((mp_digit)1 << DIGIT_BIT) - kstep)));
 
       /* add the step */
       if ((err = mp_add_d(a, step, a)) != MP_OKAY) {
@@ -139,7 +139,7 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style)
       }
 
       /* if didn't pass sieve and step == MAX then skip test */
-      if ((y == 1) && (step >= ((((mp_digit)1) << DIGIT_BIT) - kstep))) {
+      if ((y == 1) && (step >= (((mp_digit)1 << DIGIT_BIT) - kstep))) {
          continue;
       }
 
diff --git a/libtommath/bn_mp_prime_random_ex.c b/libtommath/bn_mp_prime_random_ex.c
index d3d6f3d..1ae2934 100644
--- a/libtommath/bn_mp_prime_random_ex.c
+++ b/libtommath/bn_mp_prime_random_ex.c
@@ -49,7 +49,7 @@ int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback
    bsize = (size>>3) + ((size&7)?1:0);
 
    /* we need a buffer of bsize bytes */
-   tmp = OPT_CAST(unsigned char) XMALLOC(bsize);
+   tmp = OPT_CAST(unsigned char) XMALLOC((size_t)bsize);
    if (tmp == NULL) {
       return MP_MEM;
    }
@@ -86,12 +86,12 @@ int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback
       tmp[bsize-1]             |= maskOR_lsb;
 
       /* read it in */
-      if ((err = mp_read_unsigned_bin(a, tmp, bsize)) != MP_OKAY)     {
+      if ((err = mp_read_unsigned_bin(a, tmp, bsize)) != MP_OKAY) {
          goto error;
       }
 
       /* is it prime? */
-      if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY)           {
+      if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY) {
          goto error;
       }
       if (res == MP_NO) {
@@ -100,15 +100,15 @@ int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback
 
       if ((flags & LTM_PRIME_SAFE) != 0) {
          /* see if (a-1)/2 is prime */
-         if ((err = mp_sub_d(a, 1, a)) != MP_OKAY)                    {
+         if ((err = mp_sub_d(a, 1uL, a)) != MP_OKAY) {
             goto error;
          }
-         if ((err = mp_div_2(a, a)) != MP_OKAY)                       {
+         if ((err = mp_div_2(a, a)) != MP_OKAY) {
             goto error;
          }
 
          /* is it prime? */
-         if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY)        {
+         if ((err = mp_prime_is_prime(a, t, &res)) != MP_OKAY) {
             goto error;
          }
       }
@@ -116,10 +116,10 @@ int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback
 
    if ((flags & LTM_PRIME_SAFE) != 0) {
       /* restore a to the original value */
-      if ((err = mp_mul_2(a, a)) != MP_OKAY)                          {
+      if ((err = mp_mul_2(a, a)) != MP_OKAY) {
          goto error;
       }
-      if ((err = mp_add_d(a, 1, a)) != MP_OKAY)                       {
+      if ((err = mp_add_d(a, 1uL, a)) != MP_OKAY) {
          goto error;
       }
    }
diff --git a/libtommath/bn_mp_radix_smap.c b/libtommath/bn_mp_radix_smap.c
index 4c6e57c..262775c 100644
--- a/libtommath/bn_mp_radix_smap.c
+++ b/libtommath/bn_mp_radix_smap.c
@@ -17,6 +17,20 @@
 
 /* chars used in radix conversions */
 const char *mp_s_rmap = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
+const uint8_t mp_s_rmap_reverse[] = {
+      0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f, /* ()*+,-./ */
+      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* 01234567 */
+      0x08, 0x09, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 89:;<=>? */
+      0xff, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, /* @ABCDEFG */
+      0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, /* HIJKLMNO */
+      0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, /* PQRSTUVW */
+      0x21, 0x22, 0x23, 0xff, 0xff, 0xff, 0xff, 0xff, /* XYZ[\]^_ */
+      0xff, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, /* `abcdefg */
+      0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, /* hijklmno */
+      0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, /* pqrstuvw */
+      0x3b, 0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, /* xyz{|}~. */
+};
+const size_t mp_s_rmap_reverse_sz = sizeof(mp_s_rmap_reverse);
 #endif
 
 /* ref:         $Format:%D$ */
diff --git a/libtommath/bn_mp_rand.c b/libtommath/bn_mp_rand.c
index 92a9a97..2ed665e 100644
--- a/libtommath/bn_mp_rand.c
+++ b/libtommath/bn_mp_rand.c
@@ -15,7 +15,10 @@
  * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
  */
 
-#if MP_GEN_RANDOM_MAX == 0xffffffff
+#if defined(MP_8BIT) || defined(MP_16BIT)
+#define MP_GEN_RANDOM_SHIFT  DIGIT_BIT
+#else
+#if MP_GEN_RANDOM_MAX == 0xffffffffu
 #define MP_GEN_RANDOM_SHIFT  32
 #elif MP_GEN_RANDOM_MAX == 32767
 /* SHRT_MAX */
@@ -26,6 +29,7 @@
 #elif !defined(MP_GEN_RANDOM_SHIFT)
 #error Thou shalt define their own valid MP_GEN_RANDOM_SHIFT
 #endif
+#endif
 
 /* makes a pseudo-random int of a given size */
 static mp_digit s_gen_random(void)
@@ -54,7 +58,7 @@ int mp_rand(mp_int *a, int digits)
    /* first place a random non-zero digit */
    do {
       d = s_gen_random();
-   } while (d == 0);
+   } while (d == 0u);
 
    if ((res = mp_add_d(a, d, a)) != MP_OKAY) {
       return res;
diff --git a/libtommath/bn_mp_read_radix.c b/libtommath/bn_mp_read_radix.c
index bc31cc5..55c5ee1 100644
--- a/libtommath/bn_mp_read_radix.c
+++ b/libtommath/bn_mp_read_radix.c
@@ -19,6 +19,7 @@
 int mp_read_radix(mp_int *a, const char *str, int radix)
 {
    int     y, res, neg;
+   unsigned pos;
    char    ch;
 
    /* zero the digit bignum */
@@ -49,31 +50,30 @@ int mp_read_radix(mp_int *a, const char *str, int radix)
        * [e.g. in hex]
        */
       ch = (radix <= 36) ? (char)toupper((int)*str) : *str;
-      for (y = 0; y < 64; y++) {
-         if (ch == mp_s_rmap[y]) {
-            break;
-         }
+      pos = (unsigned)(ch - '(');
+      if (mp_s_rmap_reverse_sz < pos) {
+         break;
       }
+      y = (int)mp_s_rmap_reverse[pos];
 
       /* if the char was found in the map
        * and is less than the given radix add it
        * to the number, otherwise exit the loop.
        */
-      if (y < radix) {
-         if ((res = mp_mul_d(a, (mp_digit)radix, a)) != MP_OKAY) {
-            return res;
-         }
-         if ((res = mp_add_d(a, (mp_digit)y, a)) != MP_OKAY) {
-            return res;
-         }
-      } else {
+      if ((y == 0xff) || (y >= radix)) {
          break;
       }
+      if ((res = mp_mul_d(a, (mp_digit)radix, a)) != MP_OKAY) {
+         return res;
+      }
+      if ((res = mp_add_d(a, (mp_digit)y, a)) != MP_OKAY) {
+         return res;
+      }
       ++str;
    }
 
    /* if an illegal character was found, fail. */
-   if (!(*str == '\0' || *str == '\r' || *str == '\n')) {
+   if (!((*str == '\0') || (*str == '\r') || (*str == '\n'))) {
       mp_zero(a);
       return MP_VAL;
    }
diff --git a/libtommath/bn_mp_read_signed_bin.c b/libtommath/bn_mp_read_signed_bin.c
index eabc803..17bc6ce 100644
--- a/libtommath/bn_mp_read_signed_bin.c
+++ b/libtommath/bn_mp_read_signed_bin.c
@@ -26,7 +26,7 @@ int mp_read_signed_bin(mp_int *a, const unsigned char *b, int c)
    }
 
    /* first byte is 0 for positive, non-zero for negative */
-   if (b[0] == 0) {
+   if (b[0] == (unsigned char)0) {
       a->sign = MP_ZPOS;
    } else {
       a->sign = MP_NEG;
diff --git a/libtommath/bn_mp_read_unsigned_bin.c b/libtommath/bn_mp_read_unsigned_bin.c
index ad9f05f..6398c43 100644
--- a/libtommath/bn_mp_read_unsigned_bin.c
+++ b/libtommath/bn_mp_read_unsigned_bin.c
@@ -41,7 +41,7 @@ int mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c)
       a->used += 1;
 #else
       a->dp[0] = (*b & MP_MASK);
-      a->dp[1] |= ((*b++ >> 7U) & 1);
+      a->dp[1] |= ((*b++ >> 7) & 1u);
       a->used += 2;
 #endif
    }
diff --git a/libtommath/bn_mp_reduce.c b/libtommath/bn_mp_reduce.c
index bbc521f..5b1d405 100644
--- a/libtommath/bn_mp_reduce.c
+++ b/libtommath/bn_mp_reduce.c
@@ -33,7 +33,7 @@ int mp_reduce(mp_int *x, const mp_int *m, const mp_int *mu)
    mp_rshd(&q, um - 1);
 
    /* according to HAC this optimization is ok */
-   if (((mp_digit) um) > (((mp_digit)1) << (DIGIT_BIT - 1))) {
+   if ((mp_digit)um > ((mp_digit)1 << (DIGIT_BIT - 1))) {
       if ((res = mp_mul(&q, mu, &q)) != MP_OKAY) {
          goto CLEANUP;
       }
@@ -73,8 +73,8 @@ int mp_reduce(mp_int *x, const mp_int *m, const mp_int *mu)
    }
 
    /* If x < 0, add b**(k+1) to it */
-   if (mp_cmp_d(x, 0) == MP_LT) {
-      mp_set(&q, 1);
+   if (mp_cmp_d(x, 0uL) == MP_LT) {
+      mp_set(&q, 1uL);
       if ((res = mp_lshd(&q, um + 1)) != MP_OKAY)
          goto CLEANUP;
       if ((res = mp_add(x, &q, x)) != MP_OKAY)
diff --git a/libtommath/bn_mp_reduce_2k.c b/libtommath/bn_mp_reduce_2k.c
index 2922cad..e1e2bc8 100644
--- a/libtommath/bn_mp_reduce_2k.c
+++ b/libtommath/bn_mp_reduce_2k.c
@@ -32,7 +32,7 @@ top:
       goto ERR;
    }
 
-   if (d != 1) {
+   if (d != 1u) {
       /* q = q * d */
       if ((res = mp_mul_d(&q, d, &q)) != MP_OKAY) {
          goto ERR;
diff --git a/libtommath/bn_mp_reduce_is_2k.c b/libtommath/bn_mp_reduce_is_2k.c
index 932521e..f59d535 100644
--- a/libtommath/bn_mp_reduce_is_2k.c
+++ b/libtommath/bn_mp_reduce_is_2k.c
@@ -32,7 +32,7 @@ int mp_reduce_is_2k(const mp_int *a)
 
       /* Test every bit from the second digit up, must be 1 */
       for (ix = DIGIT_BIT; ix < iy; ix++) {
-         if ((a->dp[iw] & iz) == 0) {
+         if ((a->dp[iw] & iz) == 0u) {
             return MP_NO;
          }
          iz <<= 1;
diff --git a/libtommath/bn_mp_set.c b/libtommath/bn_mp_set.c
index eaf7fed..952d080 100644
--- a/libtommath/bn_mp_set.c
+++ b/libtommath/bn_mp_set.c
@@ -20,7 +20,7 @@ void mp_set(mp_int *a, mp_digit b)
 {
    mp_zero(a);
    a->dp[0] = b & MP_MASK;
-   a->used  = (a->dp[0] != 0) ? 1 : 0;
+   a->used  = (a->dp[0] != 0u) ? 1 : 0;
 }
 #endif
 
diff --git a/libtommath/bn_mp_set_int.c b/libtommath/bn_mp_set_int.c
index 4c71180..006f263 100644
--- a/libtommath/bn_mp_set_int.c
+++ b/libtommath/bn_mp_set_int.c
@@ -30,7 +30,7 @@ int mp_set_int(mp_int *a, unsigned long b)
       }
 
       /* OR in the top four bits of the source */
-      a->dp[0] |= (b >> 28) & 15;
+      a->dp[0] |= (mp_digit)(b >> 28) & 15uL;
 
       /* shift the source up to the next four bits */
       b <<= 4;
diff --git a/libtommath/bn_mp_shrink.c b/libtommath/bn_mp_shrink.c
index 8ac1f33..3e4dde0 100644
--- a/libtommath/bn_mp_shrink.c
+++ b/libtommath/bn_mp_shrink.c
@@ -26,7 +26,7 @@ int mp_shrink(mp_int *a)
    }
 
    if (a->alloc != used) {
-      if ((tmp = OPT_CAST(mp_digit) XREALLOC(a->dp, sizeof(mp_digit) * used)) == NULL) {
+      if ((tmp = OPT_CAST(mp_digit) XREALLOC(a->dp, sizeof(mp_digit) * (size_t)used)) == NULL) {
          return MP_MEM;
       }
       a->dp    = tmp;
diff --git a/libtommath/bn_mp_sqr.c b/libtommath/bn_mp_sqr.c
index 2b71097..a98f16c 100644
--- a/libtommath/bn_mp_sqr.c
+++ b/libtommath/bn_mp_sqr.c
@@ -35,9 +35,9 @@ int mp_sqr(const mp_int *a, mp_int *b)
       {
 #ifdef BN_FAST_S_MP_SQR_C
          /* can we use the fast comba multiplier? */
-         if ((((a->used * 2) + 1) < MP_WARRAY) &&
+         if ((((a->used * 2) + 1) < (int)MP_WARRAY) &&
              (a->used <
-              (1 << (((sizeof(mp_word) * CHAR_BIT) - (2 * DIGIT_BIT)) - 1)))) {
+              (int)(1u << (((sizeof(mp_word) * (size_t)CHAR_BIT) - (2u * (size_t)DIGIT_BIT)) - 1u)))) {
             res = fast_s_mp_sqr(a, b);
          } else
 #endif
diff --git a/libtommath/bn_mp_sqrtmod_prime.c b/libtommath/bn_mp_sqrtmod_prime.c
index 261723e..d4cf3de 100644
--- a/libtommath/bn_mp_sqrtmod_prime.c
+++ b/libtommath/bn_mp_sqrtmod_prime.c
@@ -22,11 +22,11 @@ int mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret)
    mp_digit i;
 
    /* first handle the simple cases */
-   if (mp_cmp_d(n, 0) == MP_EQ) {
+   if (mp_cmp_d(n, 0uL) == MP_EQ) {
       mp_zero(ret);
       return MP_OKAY;
    }
-   if (mp_cmp_d(prime, 2) == MP_EQ)                              return MP_VAL; /* prime must be odd */
+   if (mp_cmp_d(prime, 2uL) == MP_EQ)                            return MP_VAL; /* prime must be odd */
    if ((res = mp_jacobi(n, prime, &legendre)) != MP_OKAY)        return res;
    if (legendre == -1)                                           return MP_VAL; /* quadratic non-residue mod prime */
 
@@ -38,9 +38,9 @@ int mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret)
     * compute directly: res = n^(prime+1)/4 mod prime
     * Handbook of Applied Cryptography algorithm 3.36
     */
-   if ((res = mp_mod_d(prime, 4, &i)) != MP_OKAY)                goto cleanup;
-   if (i == 3) {
-      if ((res = mp_add_d(prime, 1, &t1)) != MP_OKAY)             goto cleanup;
+   if ((res = mp_mod_d(prime, 4uL, &i)) != MP_OKAY)               goto cleanup;
+   if (i == 3u) {
+      if ((res = mp_add_d(prime, 1uL, &t1)) != MP_OKAY)           goto cleanup;
       if ((res = mp_div_2(&t1, &t1)) != MP_OKAY)                  goto cleanup;
       if ((res = mp_div_2(&t1, &t1)) != MP_OKAY)                  goto cleanup;
       if ((res = mp_exptmod(n, &t1, prime, ret)) != MP_OKAY)      goto cleanup;
@@ -52,30 +52,30 @@ int mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret)
 
    /* factor out powers of 2 from prime-1, defining Q and S as: prime-1 = Q*2^S */
    if ((res = mp_copy(prime, &Q)) != MP_OKAY)                    goto cleanup;
-   if ((res = mp_sub_d(&Q, 1, &Q)) != MP_OKAY)                   goto cleanup;
+   if ((res = mp_sub_d(&Q, 1uL, &Q)) != MP_OKAY)                 goto cleanup;
    /* Q = prime - 1 */
    mp_zero(&S);
    /* S = 0 */
    while (mp_iseven(&Q) != MP_NO) {
       if ((res = mp_div_2(&Q, &Q)) != MP_OKAY)                    goto cleanup;
       /* Q = Q / 2 */
-      if ((res = mp_add_d(&S, 1, &S)) != MP_OKAY)                 goto cleanup;
+      if ((res = mp_add_d(&S, 1uL, &S)) != MP_OKAY)               goto cleanup;
       /* S = S + 1 */
    }
 
    /* find a Z such that the Legendre symbol (Z|prime) == -1 */
-   if ((res = mp_set_int(&Z, 2)) != MP_OKAY)                     goto cleanup;
+   if ((res = mp_set_int(&Z, 2uL)) != MP_OKAY)                    goto cleanup;
    /* Z = 2 */
    while (1) {
       if ((res = mp_jacobi(&Z, prime, &legendre)) != MP_OKAY)     goto cleanup;
       if (legendre == -1) break;
-      if ((res = mp_add_d(&Z, 1, &Z)) != MP_OKAY)                 goto cleanup;
+      if ((res = mp_add_d(&Z, 1uL, &Z)) != MP_OKAY)               goto cleanup;
       /* Z = Z + 1 */
    }
 
    if ((res = mp_exptmod(&Z, &Q, prime, &C)) != MP_OKAY)         goto cleanup;
    /* C = Z ^ Q mod prime */
-   if ((res = mp_add_d(&Q, 1, &t1)) != MP_OKAY)                  goto cleanup;
+   if ((res = mp_add_d(&Q, 1uL, &t1)) != MP_OKAY)                goto cleanup;
    if ((res = mp_div_2(&t1, &t1)) != MP_OKAY)                    goto cleanup;
    /* t1 = (Q + 1) / 2 */
    if ((res = mp_exptmod(n, &t1, prime, &R)) != MP_OKAY)         goto cleanup;
@@ -84,24 +84,24 @@ int mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret)
    /* T = n ^ Q mod prime */
    if ((res = mp_copy(&S, &M)) != MP_OKAY)                       goto cleanup;
    /* M = S */
-   if ((res = mp_set_int(&two, 2)) != MP_OKAY)                   goto cleanup;
+   if ((res = mp_set_int(&two, 2uL)) != MP_OKAY)                 goto cleanup;
 
    res = MP_VAL;
    while (1) {
       if ((res = mp_copy(&T, &t1)) != MP_OKAY)                    goto cleanup;
       i = 0;
       while (1) {
-         if (mp_cmp_d(&t1, 1) == MP_EQ) break;
+         if (mp_cmp_d(&t1, 1uL) == MP_EQ) break;
          if ((res = mp_exptmod(&t1, &two, prime, &t1)) != MP_OKAY) goto cleanup;
          i++;
       }
-      if (i == 0) {
+      if (i == 0u) {
          if ((res = mp_copy(&R, ret)) != MP_OKAY)                  goto cleanup;
          res = MP_OKAY;
          goto cleanup;
       }
       if ((res = mp_sub_d(&M, i, &t1)) != MP_OKAY)                goto cleanup;
-      if ((res = mp_sub_d(&t1, 1, &t1)) != MP_OKAY)               goto cleanup;
+      if ((res = mp_sub_d(&t1, 1uL, &t1)) != MP_OKAY)             goto cleanup;
       if ((res = mp_exptmod(&two, &t1, prime, &t1)) != MP_OKAY)   goto cleanup;
       /* t1 = 2 ^ (M - i - 1) */
       if ((res = mp_exptmod(&C, &t1, prime, &t1)) != MP_OKAY)     goto cleanup;
diff --git a/libtommath/bn_mp_sub_d.c b/libtommath/bn_mp_sub_d.c
index 4d66a90..e5fbfff 100644
--- a/libtommath/bn_mp_sub_d.c
+++ b/libtommath/bn_mp_sub_d.c
@@ -67,13 +67,13 @@ int mp_sub_d(const mp_int *a, mp_digit b, mp_int *c)
 
       /* subtract first digit */
       *tmpc    = *tmpa++ - b;
-      mu       = *tmpc >> ((sizeof(mp_digit) * CHAR_BIT) - 1);
+      mu       = *tmpc >> ((sizeof(mp_digit) * (size_t)CHAR_BIT) - 1u);
       *tmpc++ &= MP_MASK;
 
       /* handle rest of the digits */
       for (ix = 1; ix < a->used; ix++) {
          *tmpc    = *tmpa++ - mu;
-         mu       = *tmpc >> ((sizeof(mp_digit) * CHAR_BIT) - 1);
+         mu       = *tmpc >> ((sizeof(mp_digit) * (size_t)CHAR_BIT) - 1u);
          *tmpc++ &= MP_MASK;
       }
    }
diff --git a/libtommath/bn_mp_to_signed_bin_n.c b/libtommath/bn_mp_to_signed_bin_n.c
index 1447624..f1d7c8b 100644
--- a/libtommath/bn_mp_to_signed_bin_n.c
+++ b/libtommath/bn_mp_to_signed_bin_n.c
@@ -21,7 +21,7 @@ int mp_to_signed_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen)
    if (*outlen < (unsigned long)mp_signed_bin_size(a)) {
       return MP_VAL;
    }
-   *outlen = mp_signed_bin_size(a);
+   *outlen = (unsigned long)mp_signed_bin_size(a);
    return mp_to_signed_bin(a, b);
 }
 #endif
diff --git a/libtommath/bn_mp_to_unsigned_bin.c b/libtommath/bn_mp_to_unsigned_bin.c
index 9339cce..a53f711 100644
--- a/libtommath/bn_mp_to_unsigned_bin.c
+++ b/libtommath/bn_mp_to_unsigned_bin.c
@@ -28,9 +28,9 @@ int mp_to_unsigned_bin(const mp_int *a, unsigned char *b)
    x = 0;
    while (mp_iszero(&t) == MP_NO) {
 #ifndef MP_8BIT
-      b[x++] = (unsigned char)(t.dp[0] & 255);
+      b[x++] = (unsigned char)(t.dp[0] & 255u);
 #else
-      b[x++] = (unsigned char)(t.dp[0] | ((t.dp[1] & 0x01) << 7));
+      b[x++] = (unsigned char)(t.dp[0] | ((t.dp[1] & 1u) << 7));
 #endif
       if ((res = mp_div_2d(&t, 8, &t, NULL)) != MP_OKAY) {
          mp_clear(&t);
diff --git a/libtommath/bn_mp_to_unsigned_bin_n.c b/libtommath/bn_mp_to_unsigned_bin_n.c
index 707dc82..e7d303c 100644
--- a/libtommath/bn_mp_to_unsigned_bin_n.c
+++ b/libtommath/bn_mp_to_unsigned_bin_n.c
@@ -21,7 +21,7 @@ int mp_to_unsigned_bin_n(const mp_int *a, unsigned char *b, unsigned long *outle
    if (*outlen < (unsigned long)mp_unsigned_bin_size(a)) {
       return MP_VAL;
    }
-   *outlen = mp_unsigned_bin_size(a);
+   *outlen = (unsigned long)mp_unsigned_bin_size(a);
    return mp_to_unsigned_bin(a, b);
 }
 #endif
diff --git a/libtommath/bn_mp_toom_mul.c b/libtommath/bn_mp_toom_mul.c
index 3554ea8..00b6bfb 100644
--- a/libtommath/bn_mp_toom_mul.c
+++ b/libtommath/bn_mp_toom_mul.c
@@ -219,7 +219,7 @@ int mp_toom_mul(const mp_int *a, const mp_int *b, mp_int *c)
       goto ERR;
    }
    /* 3r2 - r1 - r3 */
-   if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
+   if ((res = mp_mul_d(&w2, 3uL, &w2)) != MP_OKAY) {
       goto ERR;
    }
    if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
diff --git a/libtommath/bn_mp_toom_sqr.c b/libtommath/bn_mp_toom_sqr.c
index b985435..183de20 100644
--- a/libtommath/bn_mp_toom_sqr.c
+++ b/libtommath/bn_mp_toom_sqr.c
@@ -162,7 +162,7 @@ int mp_toom_sqr(const mp_int *a, mp_int *b)
       goto ERR;
    }
    /* 3r2 - r1 - r3 */
-   if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
+   if ((res = mp_mul_d(&w2, 3uL, &w2)) != MP_OKAY) {
       goto ERR;
    }
    if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
diff --git a/libtommath/bn_mp_unsigned_bin_size.c b/libtommath/bn_mp_unsigned_bin_size.c
index 04107fe..2b9ce8a 100644
--- a/libtommath/bn_mp_unsigned_bin_size.c
+++ b/libtommath/bn_mp_unsigned_bin_size.c
@@ -19,7 +19,7 @@
 int mp_unsigned_bin_size(const mp_int *a)
 {
    int     size = mp_count_bits(a);
-   return (size / 8) + (((size & 7) != 0) ? 1 : 0);
+   return (size / 8) + ((((unsigned)size & 7u) != 0u) ? 1 : 0);
 }
 #endif
 
diff --git a/libtommath/bn_prime_tab.c b/libtommath/bn_prime_tab.c
index c8fadcd..bcd23ed 100644
--- a/libtommath/bn_prime_tab.c
+++ b/libtommath/bn_prime_tab.c
@@ -14,6 +14,7 @@
  *
  * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
  */
+
 const mp_digit ltm_prime_tab[] = {
    0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013,
    0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035,
diff --git a/libtommath/bn_s_mp_add.c b/libtommath/bn_s_mp_add.c
index 2046722..3f908ef 100644
--- a/libtommath/bn_s_mp_add.c
+++ b/libtommath/bn_s_mp_add.c
@@ -67,7 +67,7 @@ int s_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
          *tmpc = *tmpa++ + *tmpb++ + u;
 
          /* U = carry bit of T[i] */
-         u = *tmpc >> ((mp_digit)DIGIT_BIT);
+         u = *tmpc >> (mp_digit)DIGIT_BIT;
 
          /* take away carry bit from T[i] */
          *tmpc++ &= MP_MASK;
@@ -82,7 +82,7 @@ int s_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
             *tmpc = x->dp[i] + u;
 
             /* U = carry bit of T[i] */
-            u = *tmpc >> ((mp_digit)DIGIT_BIT);
+            u = *tmpc >> (mp_digit)DIGIT_BIT;
 
             /* take away carry bit from T[i] */
             *tmpc++ &= MP_MASK;
diff --git a/libtommath/bn_s_mp_exptmod.c b/libtommath/bn_s_mp_exptmod.c
index a886361..a954757 100644
--- a/libtommath/bn_s_mp_exptmod.c
+++ b/libtommath/bn_s_mp_exptmod.c
@@ -14,6 +14,7 @@
  *
  * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
  */
+
 #ifdef MP_LOW_MEM
 #   define TAB_SIZE 32
 #else
@@ -25,7 +26,7 @@ int s_mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y, i
    mp_int  M[TAB_SIZE], res, mu;
    mp_digit buf;
    int     err, bitbuf, bitcpy, bitcnt, mode, digidx, x, y, winsize;
-   int (*redux)(mp_int *, const mp_int *, const mp_int *);
+   int (*redux)(mp_int *x, const mp_int *m, const mp_int *mu);
 
    /* find window size */
    x = mp_count_bits(X);
@@ -133,7 +134,7 @@ int s_mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y, i
    if ((err = mp_init(&res)) != MP_OKAY) {
       goto LBL_MU;
    }
-   mp_set(&res, 1);
+   mp_set(&res, 1uL);
 
    /* set initial mode and bit cnt */
    mode   = 0;
diff --git a/libtommath/bn_s_mp_mul_digs.c b/libtommath/bn_s_mp_mul_digs.c
index af13a02..214ae31 100644
--- a/libtommath/bn_s_mp_mul_digs.c
+++ b/libtommath/bn_s_mp_mul_digs.c
@@ -28,9 +28,9 @@ int s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
    mp_digit tmpx, *tmpt, *tmpy;
 
    /* can we use the fast multiplier? */
-   if (((digs) < MP_WARRAY) &&
+   if ((digs < (int)MP_WARRAY) &&
        (MIN(a->used, b->used) <
-        (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
+        (int)(1u << (((size_t)CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)DIGIT_BIT))))) {
       return fast_s_mp_mul_digs(a, b, c, digs);
    }
 
@@ -66,10 +66,10 @@ int s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
                    (mp_word)u;
 
          /* the new column is the lower part of the result */
-         *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
+         *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK);
 
          /* get the carry word from the result */
-         u       = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+         u       = (mp_digit)(r >> (mp_word)DIGIT_BIT);
       }
       /* set carry if it is placed below digs */
       if ((ix + iy) < digs) {
diff --git a/libtommath/bn_s_mp_mul_high_digs.c b/libtommath/bn_s_mp_mul_high_digs.c
index 37c108e..3c0418a 100644
--- a/libtommath/bn_s_mp_mul_high_digs.c
+++ b/libtommath/bn_s_mp_mul_high_digs.c
@@ -28,8 +28,8 @@ int s_mp_mul_high_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
 
    /* can we use the fast multiplier? */
 #ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C
-   if (((a->used + b->used + 1) < MP_WARRAY)
-       && (MIN(a->used, b->used) < (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
+   if (((a->used + b->used + 1) < (int)MP_WARRAY)
+       && (MIN(a->used, b->used) < (int)(1u << (((size_t)CHAR_BIT * sizeof(mp_word)) - (2u * (size_t)DIGIT_BIT))))) {
       return fast_s_mp_mul_high_digs(a, b, c, digs);
    }
 #endif
@@ -61,10 +61,10 @@ int s_mp_mul_high_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
                    (mp_word)u;
 
          /* get the lower part */
-         *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
+         *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK);
 
          /* carry the carry */
-         u       = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+         u       = (mp_digit)(r >> (mp_word)DIGIT_BIT);
       }
       *tmpt = u;
    }
diff --git a/libtommath/bn_s_mp_sqr.c b/libtommath/bn_s_mp_sqr.c
index aae06eb..71bbccd 100644
--- a/libtommath/bn_s_mp_sqr.c
+++ b/libtommath/bn_s_mp_sqr.c
@@ -38,10 +38,10 @@ int s_mp_sqr(const mp_int *a, mp_int *b)
           ((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));
+      t.dp[ix+ix] = (mp_digit)(r & (mp_word)MP_MASK);
 
       /* get the carry */
-      u           = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
+      u           = (mp_digit)(r >> (mp_word)DIGIT_BIT);
 
       /* left hand side of A[ix] * A[iy] */
       tmpx        = a->dp[ix];
@@ -51,24 +51,24 @@ int s_mp_sqr(const mp_int *a, mp_int *b)
 
       for (iy = ix + 1; iy < pa; iy++) {
          /* first calculate the product */
-         r       = ((mp_word)tmpx) * ((mp_word)a->dp[iy]);
+         r       = (mp_word)tmpx * (mp_word)a->dp[iy];
 
          /* now calculate the double precision result, note we use
           * addition instead of *2 since it's easier to optimize
           */
-         r       = ((mp_word) *tmpt) + r + r + ((mp_word) u);
+         r       = (mp_word)*tmpt + r + r + (mp_word)u;
 
          /* store lower part */
-         *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
+         *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK);
 
          /* get carry */
-         u       = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+         u       = (mp_digit)(r >> (mp_word)DIGIT_BIT);
       }
       /* propagate upwards */
-      while (u != ((mp_digit) 0)) {
-         r       = ((mp_word) *tmpt) + ((mp_word) u);
-         *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
-         u       = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
+      while (u != 0uL) {
+         r       = (mp_word)*tmpt + (mp_word)u;
+         *tmpt++ = (mp_digit)(r & (mp_word)MP_MASK);
+         u       = (mp_digit)(r >> (mp_word)DIGIT_BIT);
       }
    }
 
diff --git a/libtommath/bn_s_mp_sub.c b/libtommath/bn_s_mp_sub.c
index 52b8096..c8472af 100644
--- a/libtommath/bn_s_mp_sub.c
+++ b/libtommath/bn_s_mp_sub.c
@@ -53,7 +53,7 @@ int s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
           * if a carry does occur it will propagate all the way to the
           * MSB.  As a result a single shift is enough to get the carry
           */
-         u = *tmpc >> ((mp_digit)((CHAR_BIT * sizeof(mp_digit)) - 1));
+         u = *tmpc >> (((size_t)CHAR_BIT * sizeof(mp_digit)) - 1u);
 
          /* Clear carry from T[i] */
          *tmpc++ &= MP_MASK;
@@ -65,7 +65,7 @@ int s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
          *tmpc = *tmpa++ - u;
 
          /* U = carry bit of T[i] */
-         u = *tmpc >> ((mp_digit)((CHAR_BIT * sizeof(mp_digit)) - 1));
+         u = *tmpc >> (((size_t)CHAR_BIT * sizeof(mp_digit)) - 1u);
 
          /* Clear carry from T[i] */
          *tmpc++ &= MP_MASK;
diff --git a/libtommath/makefile b/libtommath/makefile
index 64d8fcd..5eddae4 100644
--- a/libtommath/makefile
+++ b/libtommath/makefile
@@ -102,10 +102,6 @@ test_standalone: $(LIBNAME) demo/demo.o
 mtest:
 	cd mtest ; $(CC) $(CFLAGS) -O0 mtest.c $(LFLAGS) -o mtest
 
-travis_mtest: test mtest
-	@ for i in `seq 1 10` ; do sleep 500 && echo alive; done &
-	./mtest/mtest 666666 | ./test > test.log
-
 timing: $(LIBNAME)
 	$(CC) $(CFLAGS) -DTIMER demo/timing.c $(LIBNAME) $(LFLAGS) -o ltmtest
 
@@ -148,7 +144,7 @@ new_file:
 	perl dep.pl
 
 perlcritic:
-	perlcritic *.pl
+	perlcritic *.pl doc/*.pl
 
 astyle:
-	astyle --options=astylerc $(OBJECTS:.o=.c)
+	astyle --options=astylerc $(OBJECTS:.o=.c) tommath*.h demo/*.c etc/*.c mtest/mtest.c
diff --git a/libtommath/makefile_include.mk b/libtommath/makefile_include.mk
index 3a599e8..45a4895 100644
--- a/libtommath/makefile_include.mk
+++ b/libtommath/makefile_include.mk
@@ -60,6 +60,9 @@ endif # COMPILE_DEBUG
 ifneq ($(findstring clang,$(CC)),)
 CFLAGS += -Wno-typedef-redefinition -Wno-tautological-compare -Wno-builtin-requires-header
 endif
+ifneq ($(findstring mingw,$(CC)),)
+CFLAGS += -Wno-shadow
+endif
 ifeq ($(PLATFORM), Darwin)
 CFLAGS += -Wno-nullability-completeness
 endif
diff --git a/libtommath/tommath.h b/libtommath/tommath.h
index 591076e..e229bc6 100644
--- a/libtommath/tommath.h
+++ b/libtommath/tommath.h
@@ -26,6 +26,11 @@
 extern "C" {
 #endif
 
+/* MS Visual C++ doesn't have a 128bit type for words, so fall back to 32bit MPI's (where words are 64bit) */
+#if defined(_MSC_VER) || defined(__LLP64__)
+#   define MP_32BIT
+#endif
+
 /* detect 64-bit mode if possible */
 #if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64) || \
     defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || \
@@ -63,9 +68,7 @@ typedef uint32_t             mp_word;
 #elif defined(MP_64BIT)
 /* for GCC only on supported platforms */
 typedef uint64_t mp_digit;
-#   if defined(_WIN32)
-typedef unsigned __int128    mp_word;
-#   elif defined(__GNUC__)
+#   if defined(__GNUC__)
 typedef unsigned long        mp_word __attribute__((mode(TI)));
 #   else
 /* it seems you have a problem
@@ -102,7 +105,7 @@ typedef mp_digit mp_min_u32;
 /* use arc4random on platforms that support it */
 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__)
 #   define MP_GEN_RANDOM()    arc4random()
-#   define MP_GEN_RANDOM_MAX  0xffffffff
+#   define MP_GEN_RANDOM_MAX  0xffffffffu
 #endif
 
 /* use rand() as fall-back if there's no better rand function */
@@ -157,7 +160,7 @@ extern int KARATSUBA_MUL_CUTOFF,
 #endif
 
 /* size of comba arrays, should be at least 2 * 2**(BITS_PER_WORD - BITS_PER_DIGIT*2) */
-#define MP_WARRAY               (1 << (((sizeof(mp_word) * CHAR_BIT) - (2 * DIGIT_BIT)) + 1))
+#define MP_WARRAY               (1u << (((sizeof(mp_word) * CHAR_BIT) - (2 * DIGIT_BIT)) + 1))
 
 /* the infamous mp_int structure */
 typedef struct  {
@@ -392,7 +395,7 @@ int mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast);
 int mp_sqrt(const mp_int *arg, mp_int *ret);
 
 /* special sqrt (mod prime) */
-int mp_sqrtmod_prime(const mp_int *arg, const mp_int *prime, mp_int *ret);
+int mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret);
 
 /* is number a square? */
 int mp_is_square(const mp_int *arg, int *ret);
@@ -405,13 +408,13 @@ int mp_reduce_setup(mp_int *a, const mp_int *b);
 
 /* Barrett Reduction, computes a (mod b) with a precomputed value c
  *
- * Assumes that 0 < a <= b*b, note if 0 > a > -(b*b) then you can merely
- * compute the reduction as -1 * mp_reduce(mp_abs(a)) [pseudo code].
+ * Assumes that 0 < x <= m*m, note if 0 > x > -(m*m) then you can merely
+ * compute the reduction as -1 * mp_reduce(mp_abs(x)) [pseudo code].
  */
-int mp_reduce(mp_int *a, const mp_int *b, const mp_int *c);
+int mp_reduce(mp_int *x, const mp_int *m, const mp_int *mu);
 
 /* setups the montgomery reduction */
-int mp_montgomery_setup(const mp_int *a, mp_digit *mp);
+int mp_montgomery_setup(const mp_int *n, mp_digit *rho);
 
 /* computes a = B**n mod b without division or multiplication useful for
  * normalizing numbers in a Montgomery system.
@@ -419,7 +422,7 @@ int mp_montgomery_setup(const mp_int *a, mp_digit *mp);
 int mp_montgomery_calc_normalization(mp_int *a, const mp_int *b);
 
 /* computes x/R == x (mod N) via Montgomery Reduction */
-int mp_montgomery_reduce(mp_int *a, const mp_int *m, mp_digit mp);
+int mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho);
 
 /* returns 1 if a is a valid DR modulus */
 int mp_dr_is_modulus(const mp_int *a);
@@ -427,8 +430,8 @@ int mp_dr_is_modulus(const mp_int *a);
 /* sets the value of "d" required for mp_dr_reduce */
 void mp_dr_setup(const mp_int *a, mp_digit *d);
 
-/* reduces a modulo b using the Diminished Radix method */
-int mp_dr_reduce(mp_int *a, const mp_int *b, mp_digit mp);
+/* reduces a modulo n using the Diminished Radix method */
+int mp_dr_reduce(mp_int *x, const mp_int *n, mp_digit k);
 
 /* returns true if a can be reduced with mp_reduce_2k */
 int mp_reduce_is_2k(const mp_int *a);
@@ -448,8 +451,8 @@ int mp_reduce_2k_setup_l(const mp_int *a, mp_int *d);
 /* reduces a modulo b where b is of the form 2**p - k [0 <= a] */
 int mp_reduce_2k_l(mp_int *a, const mp_int *n, const mp_int *d);
 
-/* d = a**b (mod c) */
-int mp_exptmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d);
+/* Y = G**X (mod P) */
+int mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y);
 
 /* ---> Primes <--- */
 
diff --git a/libtommath/tommath_private.h b/libtommath/tommath_private.h
index 087ddcd..678edc4 100644
--- a/libtommath/tommath_private.h
+++ b/libtommath/tommath_private.h
@@ -76,6 +76,8 @@ int s_mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y, i
 void bn_reverse(unsigned char *s, int len);
 
 extern const char *mp_s_rmap;
+extern const uint8_t mp_s_rmap_reverse[];
+extern const size_t mp_s_rmap_reverse_sz;
 
 /* Fancy macro to set an MPI from another type.
  * There are several things assumed:
@@ -99,7 +101,7 @@ int func_name (mp_int * a, type b)                       \
     }                                                    \
                                                          \
     /* OR in the top four bits of the source */          \
-    a->dp[0] |= (b >> ((sizeof(type) * 8u) - 4u)) & 15u; \
+    a->dp[0] |= (mp_digit)(b >> ((sizeof(type) * 8u) - 4u)) & 15uL;\
                                                          \
     /* shift the source up to the next four bits */      \
     b <<= 4;                                             \