Update libtommath to latest stable release (1.1.0)

4 files changed, 367 insertions, 342 deletions

diff --git a/generic/tclStubInit.c b/generic/tclStubInit.c
index f7b374c..3de8de1 100644
--- a/generic/tclStubInit.c
+++ b/generic/tclStubInit.c
@@ -849,6 +849,7 @@ const TclTomMathStubs tclTomMathStubs = {
     TclBNInitBignumFromLong, /* 64 */
     TclBNInitBignumFromWideInt, /* 65 */
     TclBNInitBignumFromWideUInt, /* 66 */
+    TclBN_mp_expt_d_ex, /* 67 */
 };
 
 static const TclStubHooks tclStubHooks = {
diff --git a/generic/tclTomMath.decls b/generic/tclTomMath.decls
index 610a031..065fe09 100644
--- a/generic/tclTomMath.decls
+++ b/generic/tclTomMath.decls
@@ -30,13 +30,13 @@ declare 1 {
 }
 
 declare 2 {
-    int TclBN_mp_add(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 3 {
-    int TclBN_mp_add_d(mp_int *a, mp_digit b, mp_int *c)
+    int TclBN_mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
 }
 declare 4 {
-    int TclBN_mp_and(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_mp_and(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 5 {
     void TclBN_mp_clamp(mp_int *a)
@@ -63,25 +63,25 @@ declare 12 {
     int TclBN_mp_count_bits(const mp_int *a)
 }
 declare 13 {
-    int TclBN_mp_div(mp_int *a, mp_int *b, mp_int *q, mp_int *r)
+    int TclBN_mp_div(const mp_int *a, const mp_int *b, mp_int *q, mp_int *r)
 }
 declare 14 {
-    int TclBN_mp_div_d(mp_int *a, mp_digit b, mp_int *q, mp_digit *r)
+    int TclBN_mp_div_d(const mp_int *a, mp_digit b, mp_int *q, mp_digit *r)
 }
 declare 15 {
-    int TclBN_mp_div_2(mp_int *a, mp_int *q)
+    int TclBN_mp_div_2(const mp_int *a, mp_int *q)
 }
 declare 16 {
     int TclBN_mp_div_2d(const mp_int *a, int b, mp_int *q, mp_int *r)
 }
 declare 17 {
-    int TclBN_mp_div_3(mp_int *a, mp_int *q, mp_digit *r)
+    int TclBN_mp_div_3(const mp_int *a, mp_int *q, mp_digit *r)
 }
 declare 18 {
     void TclBN_mp_exch(mp_int *a, mp_int *b)
 }
 declare 19 {
-    int TclBN_mp_expt_d(mp_int *a, mp_digit b, mp_int *c)
+    int TclBN_mp_expt_d(const mp_int *a, mp_digit b, mp_int *c)
 }
 declare 20 {
     int TclBN_mp_grow(mp_int *a, int size)
@@ -90,7 +90,7 @@ declare 21 {
     int TclBN_mp_init(mp_int *a)
 }
 declare 22 {
-    int TclBN_mp_init_copy(mp_int *a, mp_int *b)
+    int TclBN_mp_init_copy(mp_int *a, const mp_int *b)
 }
 declare 23 {
     int TclBN_mp_init_multi(mp_int *a, ...)
@@ -105,19 +105,19 @@ declare 26 {
     int TclBN_mp_lshd(mp_int *a, int shift)
 }
 declare 27 {
-    int TclBN_mp_mod(mp_int *a, mp_int *b, mp_int *r)
+    int TclBN_mp_mod(const mp_int *a, const mp_int *b, mp_int *r)
 }
 declare 28 {
     int TclBN_mp_mod_2d(const mp_int *a, int b, mp_int *r)
 }
 declare 29 {
-    int TclBN_mp_mul(mp_int *a, mp_int *b, mp_int *p)
+    int TclBN_mp_mul(const mp_int *a, const mp_int *b, mp_int *p)
 }
 declare 30 {
-    int TclBN_mp_mul_d(mp_int *a, mp_digit b, mp_int *p)
+    int TclBN_mp_mul_d(const mp_int *a, mp_digit b, mp_int *p)
 }
 declare 31 {
-    int TclBN_mp_mul_2(mp_int *a, mp_int *p)
+    int TclBN_mp_mul_2(const mp_int *a, mp_int *p)
 }
 declare 32 {
     int TclBN_mp_mul_2d(const mp_int *a, int d, mp_int *p)
@@ -126,10 +126,10 @@ declare 33 {
     int TclBN_mp_neg(const mp_int *a, mp_int *b)
 }
 declare 34 {
-    int TclBN_mp_or(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_mp_or(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 35 {
-    int TclBN_mp_radix_size(mp_int *a, int radix, int *size)
+    int TclBN_mp_radix_size(const mp_int *a, int radix, int *size)
 }
 declare 36 {
     int TclBN_mp_read_radix(mp_int *a, const char *str, int radix)
@@ -144,32 +144,32 @@ declare 39 {
     void TclBN_mp_set(mp_int *a, mp_digit b)
 }
 declare 40 {
-    int TclBN_mp_sqr(mp_int *a, mp_int *b)
+    int TclBN_mp_sqr(const mp_int *a, mp_int *b)
 }
 declare 41 {
-    int TclBN_mp_sqrt(mp_int *a, mp_int *b)
+    int TclBN_mp_sqrt(const mp_int *a, mp_int *b)
 }
 declare 42 {
-    int TclBN_mp_sub(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 43 {
-    int TclBN_mp_sub_d(mp_int *a, mp_digit b, mp_int *c)
+    int TclBN_mp_sub_d(const mp_int *a, mp_digit b, mp_int *c)
 }
 declare 44 {
-    int TclBN_mp_to_unsigned_bin(mp_int *a, unsigned char *b)
+    int TclBN_mp_to_unsigned_bin(const mp_int *a, unsigned char *b)
 }
 declare 45 {
-    int TclBN_mp_to_unsigned_bin_n(mp_int *a, unsigned char *b,
+    int TclBN_mp_to_unsigned_bin_n(const mp_int *a, unsigned char *b,
 	    unsigned long *outlen)
 }
 declare 46 {
-    int TclBN_mp_toradix_n(mp_int *a, char *str, int radix, int maxlen)
+    int TclBN_mp_toradix_n(const mp_int *a, char *str, int radix, int maxlen)
 }
 declare 47 {
-    int TclBN_mp_unsigned_bin_size(mp_int *a)
+    int TclBN_mp_unsigned_bin_size(const mp_int *a)
 }
 declare 48 {
-    int TclBN_mp_xor(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_mp_xor(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 49 {
     void TclBN_mp_zero(mp_int *a)
@@ -182,34 +182,34 @@ declare 50 {
     void TclBN_reverse(unsigned char *s, int len)
 }
 declare 51 {
-    int TclBN_fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
+    int TclBN_fast_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
 }
 declare 52 {
-    int TclBN_fast_s_mp_sqr(mp_int *a, mp_int *b)
+    int TclBN_fast_s_mp_sqr(const mp_int *a, mp_int *b)
 }
 declare 53 {
-    int TclBN_mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_mp_karatsuba_mul(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 54 {
-    int TclBN_mp_karatsuba_sqr(mp_int *a, mp_int *b)
+    int TclBN_mp_karatsuba_sqr(const mp_int *a, mp_int *b)
 }
 declare 55 {
-    int TclBN_mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_mp_toom_mul(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 56 {
-    int TclBN_mp_toom_sqr(mp_int *a, mp_int *b)
+    int TclBN_mp_toom_sqr(const mp_int *a, mp_int *b)
 }
 declare 57 {
-    int TclBN_s_mp_add(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_s_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 58 {
-    int TclBN_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
+    int TclBN_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
 }
 declare 59 {
-    int TclBN_s_mp_sqr(mp_int *a, mp_int *b)
+    int TclBN_s_mp_sqr(const mp_int *a, mp_int *b)
 }
 declare 60 {
-    int TclBN_s_mp_sub(mp_int *a, mp_int *b, mp_int *c)
+    int TclBN_s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 61 {
     int TclBN_mp_init_set_int(mp_int *a, unsigned long i)
@@ -233,6 +233,11 @@ declare 66 {
     void TclBNInitBignumFromWideUInt(mp_int *bignum, Tcl_WideUInt initVal)
 }
 
+# Added in libtommath 1.0
+declare 67 {
+    int TclBN_mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
+}
+
 # Local Variables:
 # mode: tcl
 # End:
diff --git a/generic/tclTomMath.h b/generic/tclTomMath.h
index 41512f0..fbf0d35 100644
--- a/generic/tclTomMath.h
+++ b/generic/tclTomMath.h
@@ -9,8 +9,6 @@
  *
  * The library is free for all purposes without any express
  * guarantee it works.
- *
- * Tom St Denis, tomstdenis@gmail.com, http://math.libtomcrypt.com
  */
 #ifndef BN_H_
 #define BN_H_
@@ -22,32 +20,25 @@
 
 
 
-#ifndef MIN
-#   define MIN(x,y) ((x)<(y)?(x):(y))
-#endif
-
-#ifndef MAX
-#   define MAX(x,y) ((x)>(y)?(x):(y))
-#endif
-
 #ifdef __cplusplus
 extern "C" {
-
-/* C++ compilers don't like assigning void * to mp_digit * */
-#define  OPT_CAST(x)  (x *)
-
-#else
-
-/* C on the other hand doesn't care */
-#define  OPT_CAST(x)
-
 #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__) || defined(__e2k__) || defined(__LCC__)
+#   define MP_32BIT
+#endif
 
 /* detect 64-bit mode if possible */
-#if defined(NEVER)  /* 128-bit ints fail in too many places */
-#   if !(defined(MP_64BIT) && defined(MP_16BIT) && defined(MP_8BIT))
-#	define MP_64BIT
+#if defined(NEVER)
+#   if !(defined(MP_32BIT) || defined(MP_16BIT) || defined(MP_8BIT))
+#      if defined(__GNUC__)
+/* we support 128bit integers only via: __attribute__((mode(TI))) */
+#         define MP_64BIT
+#      else
+/* otherwise we fall back to MP_32BIT even on 64bit platforms */
+#         define MP_32BIT
+#      endif
 #   endif
 #endif
 
@@ -61,83 +52,67 @@ extern "C" {
  */
 #ifdef MP_8BIT
 #ifndef MP_DIGIT_DECLARED
-   typedef unsigned char      mp_digit;
+typedef unsigned char        mp_digit;
 #define MP_DIGIT_DECLARED
 #endif
-   typedef unsigned short     mp_word;
+#ifndef MP_WORD_DECLARED
+typedef unsigned short       mp_word;
+#define MP_WORD_DECLARED
+#endif
+#   define MP_SIZEOF_MP_DIGIT 1
+#   ifdef DIGIT_BIT
+#      error You must not define DIGIT_BIT when using MP_8BIT
+#   endif
 #elif defined(MP_16BIT)
 #ifndef MP_DIGIT_DECLARED
-   typedef unsigned short     mp_digit;
+typedef unsigned short       mp_digit;
 #define MP_DIGIT_DECLARED
 #endif
-   typedef unsigned long      mp_word;
-#elif defined(MP_64BIT)
-   /* for GCC only on supported platforms */
-#ifndef CRYPT
-   typedef unsigned long long ulong64;
-   typedef signed long long   long64;
+#ifndef MP_WORD_DECLARED
+typedef unsigned int         mp_word;
+#define MP_WORD_DECLARED
 #endif
-
+#   define MP_SIZEOF_MP_DIGIT 2
+#   ifdef DIGIT_BIT
+#      error You must not define DIGIT_BIT when using MP_16BIT
+#   endif
+#elif defined(MP_64BIT)
+/* for GCC only on supported platforms */
 #ifndef MP_DIGIT_DECLARED
-   typedef unsigned long      mp_digit;
+typedef unsigned long long   mp_digit;
 #define MP_DIGIT_DECLARED
 #endif
-   typedef unsigned long      mp_word __attribute__ ((mode(TI)));
-
-#  define DIGIT_BIT          60
+typedef unsigned long        mp_word __attribute__((mode(TI)));
+#   define DIGIT_BIT 60
 #else
-   /* this is the default case, 28-bit digits */
-
-   /* this is to make porting into LibTomCrypt easier :-) */
-#ifndef CRYPT
-#  if defined(_MSC_VER) || defined(__BORLANDC__)
-      typedef unsigned __int64   ulong64;
-      typedef signed __int64     long64;
-#  else
-      typedef unsigned long long ulong64;
-      typedef signed long long   long64;
-#  endif
-#endif
+/* this is the default case, 28-bit digits */
 
+/* this is to make porting into LibTomCrypt easier :-) */
 #ifndef MP_DIGIT_DECLARED
-   typedef unsigned int      mp_digit;
+typedef unsigned int         mp_digit;
 #define MP_DIGIT_DECLARED
 #endif
-   typedef ulong64            mp_word;
-
-#ifdef MP_31BIT
-   /* this is an extension that uses 31-bit digits */
-#  define DIGIT_BIT          31
-#else
-   /* default case is 28-bit digits, defines MP_28BIT as a handy macro to test */
-#  define DIGIT_BIT          28
-#  define MP_28BIT
-#endif
+#ifndef MP_WORD_DECLARED
+typedef unsigned long long   mp_word;
+#define MP_WORD_DECLARED
 #endif
 
-/* define heap macros */
-#if 0 /* these are macros in tclTomMathDecls.h */
-#ifndef CRYPT
-   /* default to libc stuff */
-#  ifndef XMALLOC
-#     define XMALLOC  malloc
-#     define XFREE    free
-#     define XREALLOC realloc
-#     define XCALLOC  calloc
-#  else
-      /* prototypes for our heap functions */
-      extern void *XMALLOC(size_t n);
-      extern void *XREALLOC(void *p, size_t n);
-      extern void *XCALLOC(size_t n, size_t s);
-      extern void XFREE(void *p);
-#  endif
-#endif
+#   ifdef MP_31BIT
+/* this is an extension that uses 31-bit digits */
+#      define DIGIT_BIT 31
+#   else
+/* default case is 28-bit digits, defines MP_28BIT as a handy macro to test */
+#      define DIGIT_BIT 28
+#      define MP_28BIT
+#   endif
 #endif
 
-
 /* otherwise the bits per digit is calculated automatically from the size of a mp_digit */
 #ifndef DIGIT_BIT
-#   define DIGIT_BIT     ((int)((CHAR_BIT * sizeof(mp_digit) - 1)))  /* bits per digit */
+#   define DIGIT_BIT (((CHAR_BIT * MP_SIZEOF_MP_DIGIT) - 1))  /* bits per digit */
+typedef unsigned long mp_min_u32;
+#else
+typedef mp_digit mp_min_u32;
 #endif
 
 #define MP_DIGIT_BIT     DIGIT_BIT
@@ -170,9 +145,9 @@ typedef int           mp_err;
 /* you'll have to tune these... */
 #if defined(BUILD_tcl) || !defined(_WIN32)
 MODULE_SCOPE int KARATSUBA_MUL_CUTOFF,
-           KARATSUBA_SQR_CUTOFF,
-           TOOM_MUL_CUTOFF,
-           TOOM_SQR_CUTOFF;
+       KARATSUBA_SQR_CUTOFF,
+       TOOM_MUL_CUTOFF,
+       TOOM_SQR_CUTOFF;
 #endif
 
 /* define this to use lower memory usage routines (exptmods mostly) */
@@ -180,15 +155,15 @@ MODULE_SCOPE int KARATSUBA_MUL_CUTOFF,
 
 /* default precision */
 #ifndef MP_PREC
-#  ifndef MP_LOW_MEM
-#     define MP_PREC                 32     /* default digits of precision */
-#  else
-#     define MP_PREC                 8      /* default digits of precision */
-#  endif
+#   ifndef MP_LOW_MEM
+#      define MP_PREC 32        /* default digits of precision */
+#   else
+#      define MP_PREC 8         /* default digits of precision */
+#   endif
 #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 */
 #ifndef MP_INT_DECLARED
@@ -196,22 +171,20 @@ MODULE_SCOPE int KARATSUBA_MUL_CUTOFF,
 typedef struct mp_int mp_int;
 #endif
 struct mp_int {
-    int used, alloc, sign;
-    mp_digit *dp;
+   int used, alloc, sign;
+   mp_digit *dp;
 };
 
 /* callback for mp_prime_random, should fill dst with random bytes and return how many read [upto len] */
 typedef int ltm_prime_callback(unsigned char *dst, int len, void *dat);
 
 
-#define USED(m)    ((m)->used)
-#define DIGIT(m,k) ((m)->dp[(k)])
-#define SIGN(m)    ((m)->sign)
+#define USED(m)     ((m)->used)
+#define DIGIT(m, k) ((m)->dp[(k)])
+#define SIGN(m)     ((m)->sign)
 
 /* error code to char* string */
-/*
-char *mp_error_to_string(int code);
-*/
+const char *mp_error_to_string(int code);
 
 /* ---> init and deinit bignum functions <--- */
 /* init a bignum */
@@ -256,8 +229,9 @@ int mp_init_size(mp_int *a, int size);
 
 /* ---> Basic Manipulations <--- */
 #define mp_iszero(a) (((a)->used == 0) ? MP_YES : MP_NO)
-#define mp_iseven(a) (((a)->used == 0 || (((a)->dp[0] & 1) == 0)) ? MP_YES : MP_NO)
-#define mp_isodd(a)  (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? MP_YES : MP_NO)
+#define mp_iseven(a) ((((a)->used == 0) || (((a)->dp[0] & 1u) == 0u)) ? MP_YES : MP_NO)
+#define mp_isodd(a)  ((((a)->used > 0) && (((a)->dp[0] & 1u) == 1u)) ? MP_YES : MP_NO)
+#define mp_isneg(a)  (((a)->sign != MP_ZPOS) ? MP_YES : MP_NO)
 
 /* set to zero */
 /*
@@ -274,17 +248,39 @@ void mp_set(mp_int *a, mp_digit b);
 int mp_set_int(mp_int *a, unsigned long b);
 */
 
+/* set a platform dependent unsigned long value */
+/*
+int mp_set_long(mp_int *a, unsigned long b);
+*/
+
+/* set a platform dependent unsigned long long value */
+/*
+int mp_set_long_long(mp_int *a, unsigned long long b);
+*/
+
 /* get a 32-bit value */
-unsigned long mp_get_int(mp_int * a);
+/*
+unsigned long mp_get_int(const mp_int *a);
+*/
+
+/* get a platform dependent unsigned long value */
+/*
+unsigned long mp_get_long(const mp_int *a);
+*/
+
+/* get a platform dependent unsigned long long value */
+/*
+unsigned long long mp_get_long_long(const mp_int *a);
+*/
 
 /* initialize and set a digit */
 /*
-int mp_init_set (mp_int * a, mp_digit b);
+int mp_init_set(mp_int *a, mp_digit b);
 */
 
 /* initialize and set 32-bit value */
 /*
-int mp_init_set_int (mp_int * a, unsigned long b);
+int mp_init_set_int(mp_int *a, unsigned long b);
 */
 
 /* copy, b = a */
@@ -294,7 +290,7 @@ int mp_copy(const mp_int *a, mp_int *b);
 
 /* inits and copies, a = b */
 /*
-int mp_init_copy(mp_int *a, mp_int *b);
+int mp_init_copy(mp_int *a, const mp_int *b);
 */
 
 /* trim unused digits */
@@ -302,6 +298,16 @@ int mp_init_copy(mp_int *a, mp_int *b);
 void mp_clamp(mp_int *a);
 */
 
+/* import binary data */
+/*
+int mp_import(mp_int *rop, size_t count, int order, size_t size, int endian, size_t nails, const void *op);
+*/
+
+/* export binary data */
+/*
+int mp_export(void *rop, size_t *countp, int order, size_t size, int endian, size_t nails, const mp_int *op);
+*/
+
 /* ---> digit manipulation <--- */
 
 /* right shift by "b" digits */
@@ -314,27 +320,27 @@ void mp_rshd(mp_int *a, int b);
 int mp_lshd(mp_int *a, int b);
 */
 
-/* c = a / 2**b */
+/* c = a / 2**b, implemented as c = a >> b */
 /*
 int mp_div_2d(const mp_int *a, int b, mp_int *c, mp_int *d);
 */
 
 /* b = a/2 */
 /*
-int mp_div_2(mp_int *a, mp_int *b);
+int mp_div_2(const mp_int *a, mp_int *b);
 */
 
-/* c = a * 2**b */
+/* c = a * 2**b, implemented as c = a << b */
 /*
 int mp_mul_2d(const mp_int *a, int b, mp_int *c);
 */
 
 /* b = a*2 */
 /*
-int mp_mul_2(mp_int *a, mp_int *b);
+int mp_mul_2(const mp_int *a, mp_int *b);
 */
 
-/* c = a mod 2**d */
+/* c = a mod 2**b */
 /*
 int mp_mod_2d(const mp_int *a, int b, mp_int *c);
 */
@@ -356,24 +362,57 @@ int mp_cnt_lsb(const mp_int *a);
 int mp_rand(mp_int *a, int digits);
 */
 
+#ifdef MP_PRNG_ENABLE_LTM_RNG
+/* as last resort we will fall back to libtomcrypt's rng_get_bytes()
+ * in case you don't use libtomcrypt or use it w/o rng_get_bytes()
+ * you have to implement it somewhere else, as it's required */
+extern unsigned long (*ltm_rng)(unsigned char *out, unsigned long outlen, void (*callback)(void));
+extern void (*ltm_rng_callback)(void);
+#endif
+
 /* ---> binary operations <--- */
 /* c = a XOR b  */
 /*
-int mp_xor(mp_int *a, mp_int *b, mp_int *c);
+int mp_xor(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* c = a OR b */
 /*
-int mp_or(mp_int *a, mp_int *b, mp_int *c);
+int mp_or(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* c = a AND b */
 /*
-int mp_and(mp_int *a, mp_int *b, mp_int *c);
+int mp_and(const mp_int *a, const mp_int *b, mp_int *c);
+*/
+
+/* c = a XOR b (two complement) */
+/*
+int mp_tc_xor(const mp_int *a, const mp_int *b, mp_int *c);
+*/
+
+/* c = a OR b (two complement) */
+/*
+int mp_tc_or(const mp_int *a, const mp_int *b, mp_int *c);
+*/
+
+/* c = a AND b (two complement) */
+/*
+int mp_tc_and(const mp_int *a, const mp_int *b, mp_int *c);
+*/
+
+/* right shift (two complement) */
+/*
+int mp_tc_div_2d(const mp_int *a, int b, mp_int *c);
 */
 
 /* ---> Basic arithmetic <--- */
 
+/* b = ~a */
+/*
+int mp_complement(const mp_int *a, mp_int *b);
+*/
+
 /* b = -a */
 /*
 int mp_neg(const mp_int *a, mp_int *b);
@@ -381,7 +420,7 @@ int mp_neg(const mp_int *a, mp_int *b);
 
 /* b = |a| */
 /*
-int mp_abs(mp_int *a, mp_int *b);
+int mp_abs(const mp_int *a, mp_int *b);
 */
 
 /* compare a to b */
@@ -396,32 +435,32 @@ int mp_cmp_mag(const mp_int *a, const mp_int *b);
 
 /* c = a + b */
 /*
-int mp_add(mp_int *a, mp_int *b, mp_int *c);
+int mp_add(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* c = a - b */
 /*
-int mp_sub(mp_int *a, mp_int *b, mp_int *c);
+int mp_sub(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* c = a * b */
 /*
-int mp_mul(mp_int *a, mp_int *b, mp_int *c);
+int mp_mul(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* b = a*a  */
 /*
-int mp_sqr(mp_int *a, mp_int *b);
+int mp_sqr(const mp_int *a, mp_int *b);
 */
 
 /* a/b => cb + d == a */
 /*
-int mp_div(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+int mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d);
 */
 
 /* c = a mod b, 0 <= c < b  */
 /*
-int mp_mod(mp_int *a, mp_int *b, mp_int *c);
+int mp_mod(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* ---> single digit functions <--- */
@@ -433,79 +472,82 @@ int mp_cmp_d(const mp_int *a, mp_digit b);
 
 /* c = a + b */
 /*
-int mp_add_d(mp_int *a, mp_digit b, mp_int *c);
+int mp_add_d(const mp_int *a, mp_digit b, mp_int *c);
 */
 
 /* c = a - b */
 /*
-int mp_sub_d(mp_int *a, mp_digit b, mp_int *c);
+int mp_sub_d(const mp_int *a, mp_digit b, mp_int *c);
 */
 
 /* c = a * b */
 /*
-int mp_mul_d(mp_int *a, mp_digit b, mp_int *c);
+int mp_mul_d(const 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);
+int mp_div_d(const 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);
+int mp_div_3(const 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);
+int mp_expt_d(const mp_int *a, mp_digit b, mp_int *c);
+*/
+/*
+int mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast);
 */
 
 /* c = a mod b, 0 <= c < b  */
 /*
-int mp_mod_d(mp_int *a, mp_digit b, mp_digit *c);
+int mp_mod_d(const mp_int *a, mp_digit b, mp_digit *c);
 */
 
 /* ---> number theory <--- */
 
 /* d = a + b (mod c) */
 /*
-int mp_addmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+int mp_addmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d);
 */
 
 /* d = a - b (mod c) */
 /*
-int mp_submod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+int mp_submod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d);
 */
 
 /* d = a * b (mod c) */
 /*
-int mp_mulmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+int mp_mulmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d);
 */
 
 /* c = a * a (mod b) */
 /*
-int mp_sqrmod(mp_int *a, mp_int *b, mp_int *c);
+int mp_sqrmod(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* c = 1/a (mod b) */
 /*
-int mp_invmod(mp_int *a, mp_int *b, mp_int *c);
+int mp_invmod(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* c = (a, b) */
 /*
-int mp_gcd(mp_int *a, mp_int *b, mp_int *c);
+int mp_gcd(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* produces value such that U1*a + U2*b = U3 */
 /*
-int mp_exteuclid(mp_int *a, mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3);
+int mp_exteuclid(const mp_int *a, const mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3);
 */
 
 /* c = [a, b] or (a*b)/(a, b) */
 /*
-int mp_lcm(mp_int *a, mp_int *b, mp_int *c);
+int mp_lcm(const mp_int *a, const mp_int *b, mp_int *c);
 */
 
 /* finds one of the b'th root of a, such that |c|**b <= |a|
@@ -513,136 +555,144 @@ int mp_lcm(mp_int *a, mp_int *b, mp_int *c);
  * returns error if a < 0 and b is even
  */
 /*
-int mp_n_root(mp_int *a, mp_digit b, mp_int *c);
+int mp_n_root(const mp_int *a, mp_digit b, mp_int *c);
+*/
+/*
+int mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast);
 */
 
 /* special sqrt algo */
 /*
-int mp_sqrt(mp_int *arg, mp_int *ret);
+int mp_sqrt(const mp_int *arg, mp_int *ret);
+*/
+
+/* special sqrt (mod prime) */
+/*
+int mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret);
 */
 
 /* is number a square? */
 /*
-int mp_is_square(mp_int *arg, int *ret);
+int mp_is_square(const mp_int *arg, int *ret);
 */
 
 /* computes the jacobi c = (a | n) (or Legendre if b is prime)  */
 /*
-int mp_jacobi(mp_int *a, mp_int *n, int *c);
+int mp_jacobi(const mp_int *a, const mp_int *n, int *c);
 */
 
 /* used to setup the Barrett reduction for a given modulus b */
 /*
-int mp_reduce_setup(mp_int *a, mp_int *b);
+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, mp_int *b, 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(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.
  */
 /*
-int mp_montgomery_calc_normalization(mp_int *a, mp_int *b);
+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, 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(mp_int *a);
+int mp_dr_is_modulus(const mp_int *a);
 */
 
 /* sets the value of "d" required for mp_dr_reduce */
 /*
-void mp_dr_setup(mp_int *a, mp_digit *d);
+void mp_dr_setup(const mp_int *a, mp_digit *d);
 */
 
-/* reduces a modulo b using the Diminished Radix method */
+/* reduces a modulo n using the Diminished Radix method */
 /*
-int mp_dr_reduce(mp_int *a, mp_int *b, mp_digit mp);
+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(mp_int *a);
+int mp_reduce_is_2k(const mp_int *a);
 */
 
 /* determines k value for 2k reduction */
 /*
-int mp_reduce_2k_setup(mp_int *a, mp_digit *d);
+int mp_reduce_2k_setup(const 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 d);
+int mp_reduce_2k(mp_int *a, const mp_int *n, mp_digit d);
 */
 
 /* returns true if a can be reduced with mp_reduce_2k_l */
 /*
-int mp_reduce_is_2k_l(mp_int *a);
+int mp_reduce_is_2k_l(const mp_int *a);
 */
 
 /* determines k value for 2k reduction */
 /*
-int mp_reduce_2k_setup_l(mp_int *a, mp_int *d);
+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, mp_int *n, mp_int *d);
+int mp_reduce_2k_l(mp_int *a, const mp_int *n, const mp_int *d);
 */
 
-/* d = a**b (mod c) */
+/* Y = G**X (mod P) */
 /*
-int mp_exptmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d);
+int mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y);
 */
 
 /* ---> Primes <--- */
 
 /* number of primes */
 #ifdef MP_8BIT
-#  define PRIME_SIZE      31
+#  define PRIME_SIZE 31
 #else
-#  define PRIME_SIZE      256
+#  define PRIME_SIZE 256
 #endif
 
 /* table of first PRIME_SIZE primes */
 #if defined(BUILD_tcl) || !defined(_WIN32)
-MODULE_SCOPE const mp_digit ltm_prime_tab[];
+MODULE_SCOPE const mp_digit ltm_prime_tab[PRIME_SIZE];
 #endif
 
 /* result=1 if a is divisible by one of the first PRIME_SIZE primes */
 /*
-int mp_prime_is_divisible(mp_int *a, int *result);
+int mp_prime_is_divisible(const mp_int *a, int *result);
 */
 
 /* performs one Fermat test of "a" using base "b".
  * Sets result to 0 if composite or 1 if probable prime
  */
 /*
-int mp_prime_fermat(mp_int *a, mp_int *b, int *result);
+int mp_prime_fermat(const mp_int *a, const mp_int *b, int *result);
 */
 
 /* performs one Miller-Rabin test of "a" using base "b".
  * Sets result to 0 if composite or 1 if probable prime
  */
 /*
-int mp_prime_miller_rabin(mp_int *a, mp_int *b, int *result);
+int mp_prime_miller_rabin(const mp_int *a, const mp_int *b, int *result);
 */
 
 /* This gives [for a given bit size] the number of trials required
@@ -660,7 +710,7 @@ int mp_prime_rabin_miller_trials(int size);
  * Sets result to 1 if probably prime, 0 otherwise
  */
 /*
-int mp_prime_is_prime(mp_int *a, int t, int *result);
+int mp_prime_is_prime(const mp_int *a, int t, int *result);
 */
 
 /* finds the next prime after the number "a" using "t" trials
@@ -689,7 +739,6 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style);
  *
  *   LTM_PRIME_BBS      - make prime congruent to 3 mod 4
  *   LTM_PRIME_SAFE     - make sure (p-1)/2 is prime as well (implies LTM_PRIME_BBS)
- *   LTM_PRIME_2MSB_OFF - make the 2nd highest bit zero
  *   LTM_PRIME_2MSB_ON  - make the 2nd highest bit one
  *
  * You have to supply a callback which fills in a buffer with random bytes.  "dat" is a parameter you can
@@ -707,50 +756,52 @@ int mp_count_bits(const mp_int *a);
 */
 
 /*
-int mp_unsigned_bin_size(mp_int *a);
+int mp_unsigned_bin_size(const mp_int *a);
 */
 /*
 int mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c);
 */
 /*
-int mp_to_unsigned_bin(mp_int *a, unsigned char *b);
+int mp_to_unsigned_bin(const mp_int *a, unsigned char *b);
 */
 /*
-int mp_to_unsigned_bin_n (mp_int * a, unsigned char *b, unsigned long *outlen);
+int mp_to_unsigned_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen);
 */
 
 /*
-int mp_signed_bin_size(mp_int *a);
+int mp_signed_bin_size(const mp_int *a);
 */
 /*
 int mp_read_signed_bin(mp_int *a, const unsigned char *b, int c);
 */
 /*
-int mp_to_signed_bin(mp_int *a,  unsigned char *b);
+int mp_to_signed_bin(const mp_int *a,  unsigned char *b);
 */
 /*
-int mp_to_signed_bin_n (mp_int * a, unsigned char *b, unsigned long *outlen);
+int mp_to_signed_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen);
 */
 
 /*
 int mp_read_radix(mp_int *a, const char *str, int radix);
 */
 /*
-int mp_toradix(mp_int *a, char *str, int radix);
+int mp_toradix(const mp_int *a, char *str, int radix);
 */
 /*
-int mp_toradix_n(mp_int * a, char *str, int radix, int maxlen);
+int mp_toradix_n(const mp_int *a, char *str, int radix, int maxlen);
 */
 /*
-int mp_radix_size(mp_int *a, int radix, int *size);
+int mp_radix_size(const mp_int *a, int radix, int *size);
 */
 
+#ifndef LTM_NO_FILE
 /*
 int mp_fread(mp_int *a, int radix, FILE *stream);
 */
 /*
-int mp_fwrite(mp_int *a, int radix, FILE *stream);
+int mp_fwrite(const mp_int *a, int radix, FILE *stream);
 */
+#endif
 
 #define mp_read_raw(mp, str, len) mp_read_signed_bin((mp), (str), (len))
 #define mp_raw_size(mp)           mp_signed_bin_size(mp)
@@ -764,69 +815,14 @@ int mp_fwrite(mp_int *a, int radix, FILE *stream);
 #define mp_todecimal(M, S) mp_toradix((M), (S), 10)
 #define mp_tohex(M, S)     mp_toradix((M), (S), 16)
 
-/* lowlevel functions, do not call! */
-/*
-int s_mp_add(mp_int *a, mp_int *b, mp_int *c);
-*/
-/*
-int s_mp_sub(mp_int *a, mp_int *b, mp_int *c);
-*/
-#define s_mp_mul(a, b, c) s_mp_mul_digs(a, b, c, (a)->used + (b)->used + 1)
-/*
-int fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
-*/
-/*
-int s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
-*/
-/*
-int fast_s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs);
-*/
-/*
-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 mp_invmod_slow (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, int mode);
-*/
-/*
-void bn_reverse(unsigned char *s, int len);
-*/
-
-#if defined(BUILD_tcl) || !defined(_WIN32)
-MODULE_SCOPE const char *mp_s_rmap;
-#endif
-
 #ifdef __cplusplus
 }
 #endif
 
 #endif
+
+
+/* ref:         $Format:%D$ */
+/* git commit:  $Format:%H$ */
+/* commit time: $Format:%ai$ */
+
diff --git a/generic/tclTomMathDecls.h b/generic/tclTomMathDecls.h
index 2ce9d5a..81cd7c9 100644
--- a/generic/tclTomMathDecls.h
+++ b/generic/tclTomMathDecls.h
@@ -73,6 +73,7 @@
 #define mp_div_d TclBN_mp_div_d
 #define mp_exch TclBN_mp_exch
 #define mp_expt_d TclBN_mp_expt_d
+#define mp_expt_d_ex TclBN_mp_expt_d_ex
 #define mp_grow TclBN_mp_grow
 #define mp_init TclBN_mp_init
 #define mp_init_copy TclBN_mp_init_copy
@@ -94,7 +95,6 @@
 #define mp_radix_size TclBN_mp_radix_size
 #define mp_read_radix TclBN_mp_read_radix
 #define mp_rshd TclBN_mp_rshd
-#define mp_s_rmap TclBNMpSRmap
 #define mp_set TclBN_mp_set
 #define mp_set_int TclBN_mp_set_int
 #define mp_shrink TclBN_mp_shrink
@@ -147,11 +147,14 @@ EXTERN int		TclBN_epoch(void);
 /* 1 */
 EXTERN int		TclBN_revision(void);
 /* 2 */
-EXTERN int		TclBN_mp_add(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_add(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 3 */
-EXTERN int		TclBN_mp_add_d(mp_int *a, mp_digit b, mp_int *c);
+EXTERN int		TclBN_mp_add_d(const mp_int *a, mp_digit b,
+				mp_int *c);
 /* 4 */
-EXTERN int		TclBN_mp_and(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_and(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 5 */
 EXTERN void		TclBN_mp_clamp(mp_int *a);
 /* 6 */
@@ -169,28 +172,30 @@ EXTERN int		TclBN_mp_copy(const mp_int *a, mp_int *b);
 /* 12 */
 EXTERN int		TclBN_mp_count_bits(const mp_int *a);
 /* 13 */
-EXTERN int		TclBN_mp_div(mp_int *a, mp_int *b, mp_int *q,
-				mp_int *r);
+EXTERN int		TclBN_mp_div(const mp_int *a, const mp_int *b,
+				mp_int *q, mp_int *r);
 /* 14 */
-EXTERN int		TclBN_mp_div_d(mp_int *a, mp_digit b, mp_int *q,
-				mp_digit *r);
+EXTERN int		TclBN_mp_div_d(const mp_int *a, mp_digit b,
+				mp_int *q, mp_digit *r);
 /* 15 */
-EXTERN int		TclBN_mp_div_2(mp_int *a, mp_int *q);
+EXTERN int		TclBN_mp_div_2(const mp_int *a, mp_int *q);
 /* 16 */
 EXTERN int		TclBN_mp_div_2d(const mp_int *a, int b, mp_int *q,
 				mp_int *r);
 /* 17 */
-EXTERN int		TclBN_mp_div_3(mp_int *a, mp_int *q, mp_digit *r);
+EXTERN int		TclBN_mp_div_3(const mp_int *a, mp_int *q,
+				mp_digit *r);
 /* 18 */
 EXTERN void		TclBN_mp_exch(mp_int *a, mp_int *b);
 /* 19 */
-EXTERN int		TclBN_mp_expt_d(mp_int *a, mp_digit b, mp_int *c);
+EXTERN int		TclBN_mp_expt_d(const mp_int *a, mp_digit b,
+				mp_int *c);
 /* 20 */
 EXTERN int		TclBN_mp_grow(mp_int *a, int size);
 /* 21 */
 EXTERN int		TclBN_mp_init(mp_int *a);
 /* 22 */
-EXTERN int		TclBN_mp_init_copy(mp_int *a, mp_int *b);
+EXTERN int		TclBN_mp_init_copy(mp_int *a, const mp_int *b);
 /* 23 */
 EXTERN int		TclBN_mp_init_multi(mp_int *a, ...);
 /* 24 */
@@ -200,23 +205,28 @@ EXTERN int		TclBN_mp_init_size(mp_int *a, int size);
 /* 26 */
 EXTERN int		TclBN_mp_lshd(mp_int *a, int shift);
 /* 27 */
-EXTERN int		TclBN_mp_mod(mp_int *a, mp_int *b, mp_int *r);
+EXTERN int		TclBN_mp_mod(const mp_int *a, const mp_int *b,
+				mp_int *r);
 /* 28 */
 EXTERN int		TclBN_mp_mod_2d(const mp_int *a, int b, mp_int *r);
 /* 29 */
-EXTERN int		TclBN_mp_mul(mp_int *a, mp_int *b, mp_int *p);
+EXTERN int		TclBN_mp_mul(const mp_int *a, const mp_int *b,
+				mp_int *p);
 /* 30 */
-EXTERN int		TclBN_mp_mul_d(mp_int *a, mp_digit b, mp_int *p);
+EXTERN int		TclBN_mp_mul_d(const mp_int *a, mp_digit b,
+				mp_int *p);
 /* 31 */
-EXTERN int		TclBN_mp_mul_2(mp_int *a, mp_int *p);
+EXTERN int		TclBN_mp_mul_2(const mp_int *a, mp_int *p);
 /* 32 */
 EXTERN int		TclBN_mp_mul_2d(const mp_int *a, int d, mp_int *p);
 /* 33 */
 EXTERN int		TclBN_mp_neg(const mp_int *a, mp_int *b);
 /* 34 */
-EXTERN int		TclBN_mp_or(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_or(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 35 */
-EXTERN int		TclBN_mp_radix_size(mp_int *a, int radix, int *size);
+EXTERN int		TclBN_mp_radix_size(const mp_int *a, int radix,
+				int *size);
 /* 36 */
 EXTERN int		TclBN_mp_read_radix(mp_int *a, const char *str,
 				int radix);
@@ -227,52 +237,59 @@ EXTERN int		TclBN_mp_shrink(mp_int *a);
 /* 39 */
 EXTERN void		TclBN_mp_set(mp_int *a, mp_digit b);
 /* 40 */
-EXTERN int		TclBN_mp_sqr(mp_int *a, mp_int *b);
+EXTERN int		TclBN_mp_sqr(const mp_int *a, mp_int *b);
 /* 41 */
-EXTERN int		TclBN_mp_sqrt(mp_int *a, mp_int *b);
+EXTERN int		TclBN_mp_sqrt(const mp_int *a, mp_int *b);
 /* 42 */
-EXTERN int		TclBN_mp_sub(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_sub(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 43 */
-EXTERN int		TclBN_mp_sub_d(mp_int *a, mp_digit b, mp_int *c);
+EXTERN int		TclBN_mp_sub_d(const mp_int *a, mp_digit b,
+				mp_int *c);
 /* 44 */
-EXTERN int		TclBN_mp_to_unsigned_bin(mp_int *a, unsigned char *b);
+EXTERN int		TclBN_mp_to_unsigned_bin(const mp_int *a,
+				unsigned char *b);
 /* 45 */
-EXTERN int		TclBN_mp_to_unsigned_bin_n(mp_int *a,
+EXTERN int		TclBN_mp_to_unsigned_bin_n(const mp_int *a,
 				unsigned char *b, unsigned long *outlen);
 /* 46 */
-EXTERN int		TclBN_mp_toradix_n(mp_int *a, char *str, int radix,
-				int maxlen);
+EXTERN int		TclBN_mp_toradix_n(const mp_int *a, char *str,
+				int radix, int maxlen);
 /* 47 */
-EXTERN int		TclBN_mp_unsigned_bin_size(mp_int *a);
+EXTERN int		TclBN_mp_unsigned_bin_size(const mp_int *a);
 /* 48 */
-EXTERN int		TclBN_mp_xor(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_xor(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 49 */
 EXTERN void		TclBN_mp_zero(mp_int *a);
 /* 50 */
 EXTERN void		TclBN_reverse(unsigned char *s, int len);
 /* 51 */
-EXTERN int		TclBN_fast_s_mp_mul_digs(mp_int *a, mp_int *b,
-				mp_int *c, int digs);
+EXTERN int		TclBN_fast_s_mp_mul_digs(const mp_int *a,
+				const mp_int *b, mp_int *c, int digs);
 /* 52 */
-EXTERN int		TclBN_fast_s_mp_sqr(mp_int *a, mp_int *b);
+EXTERN int		TclBN_fast_s_mp_sqr(const mp_int *a, mp_int *b);
 /* 53 */
-EXTERN int		TclBN_mp_karatsuba_mul(mp_int *a, mp_int *b,
-				mp_int *c);
+EXTERN int		TclBN_mp_karatsuba_mul(const mp_int *a,
+				const mp_int *b, mp_int *c);
 /* 54 */
-EXTERN int		TclBN_mp_karatsuba_sqr(mp_int *a, mp_int *b);
+EXTERN int		TclBN_mp_karatsuba_sqr(const mp_int *a, mp_int *b);
 /* 55 */
-EXTERN int		TclBN_mp_toom_mul(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_toom_mul(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 56 */
-EXTERN int		TclBN_mp_toom_sqr(mp_int *a, mp_int *b);
+EXTERN int		TclBN_mp_toom_sqr(const mp_int *a, mp_int *b);
 /* 57 */
-EXTERN int		TclBN_s_mp_add(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_s_mp_add(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 58 */
-EXTERN int		TclBN_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c,
-				int digs);
+EXTERN int		TclBN_s_mp_mul_digs(const mp_int *a, const mp_int *b,
+				mp_int *c, int digs);
 /* 59 */
-EXTERN int		TclBN_s_mp_sqr(mp_int *a, mp_int *b);
+EXTERN int		TclBN_s_mp_sqr(const mp_int *a, mp_int *b);
 /* 60 */
-EXTERN int		TclBN_s_mp_sub(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_s_mp_sub(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 61 */
 EXTERN int		TclBN_mp_init_set_int(mp_int *a, unsigned long i);
 /* 62 */
@@ -287,6 +304,9 @@ EXTERN void		TclBNInitBignumFromWideInt(mp_int *bignum,
 /* 66 */
 EXTERN void		TclBNInitBignumFromWideUInt(mp_int *bignum,
 				Tcl_WideUInt initVal);
+/* 67 */
+EXTERN int		TclBN_mp_expt_d_ex(const mp_int *a, mp_digit b,
+				mp_int *c, int fast);
 
 typedef struct TclTomMathStubs {
     int magic;
@@ -294,9 +314,9 @@ typedef struct TclTomMathStubs {
 
     int (*tclBN_epoch) (void); /* 0 */
     int (*tclBN_revision) (void); /* 1 */
-    int (*tclBN_mp_add) (mp_int *a, mp_int *b, mp_int *c); /* 2 */
-    int (*tclBN_mp_add_d) (mp_int *a, mp_digit b, mp_int *c); /* 3 */
-    int (*tclBN_mp_and) (mp_int *a, mp_int *b, mp_int *c); /* 4 */
+    int (*tclBN_mp_add) (const mp_int *a, const mp_int *b, mp_int *c); /* 2 */
+    int (*tclBN_mp_add_d) (const mp_int *a, mp_digit b, mp_int *c); /* 3 */
+    int (*tclBN_mp_and) (const mp_int *a, const mp_int *b, mp_int *c); /* 4 */
     void (*tclBN_mp_clamp) (mp_int *a); /* 5 */
     void (*tclBN_mp_clear) (mp_int *a); /* 6 */
     void (*tclBN_mp_clear_multi) (mp_int *a, ...); /* 7 */
@@ -305,60 +325,61 @@ typedef struct TclTomMathStubs {
     int (*tclBN_mp_cmp_mag) (const mp_int *a, const mp_int *b); /* 10 */
     int (*tclBN_mp_copy) (const mp_int *a, mp_int *b); /* 11 */
     int (*tclBN_mp_count_bits) (const mp_int *a); /* 12 */
-    int (*tclBN_mp_div) (mp_int *a, mp_int *b, mp_int *q, mp_int *r); /* 13 */
-    int (*tclBN_mp_div_d) (mp_int *a, mp_digit b, mp_int *q, mp_digit *r); /* 14 */
-    int (*tclBN_mp_div_2) (mp_int *a, mp_int *q); /* 15 */
+    int (*tclBN_mp_div) (const mp_int *a, const mp_int *b, mp_int *q, mp_int *r); /* 13 */
+    int (*tclBN_mp_div_d) (const mp_int *a, mp_digit b, mp_int *q, mp_digit *r); /* 14 */
+    int (*tclBN_mp_div_2) (const mp_int *a, mp_int *q); /* 15 */
     int (*tclBN_mp_div_2d) (const mp_int *a, int b, mp_int *q, mp_int *r); /* 16 */
-    int (*tclBN_mp_div_3) (mp_int *a, mp_int *q, mp_digit *r); /* 17 */
+    int (*tclBN_mp_div_3) (const mp_int *a, mp_int *q, mp_digit *r); /* 17 */
     void (*tclBN_mp_exch) (mp_int *a, mp_int *b); /* 18 */
-    int (*tclBN_mp_expt_d) (mp_int *a, mp_digit b, mp_int *c); /* 19 */
+    int (*tclBN_mp_expt_d) (const mp_int *a, mp_digit b, mp_int *c); /* 19 */
     int (*tclBN_mp_grow) (mp_int *a, int size); /* 20 */
     int (*tclBN_mp_init) (mp_int *a); /* 21 */
-    int (*tclBN_mp_init_copy) (mp_int *a, mp_int *b); /* 22 */
+    int (*tclBN_mp_init_copy) (mp_int *a, const mp_int *b); /* 22 */
     int (*tclBN_mp_init_multi) (mp_int *a, ...); /* 23 */
     int (*tclBN_mp_init_set) (mp_int *a, mp_digit b); /* 24 */
     int (*tclBN_mp_init_size) (mp_int *a, int size); /* 25 */
     int (*tclBN_mp_lshd) (mp_int *a, int shift); /* 26 */
-    int (*tclBN_mp_mod) (mp_int *a, mp_int *b, mp_int *r); /* 27 */
+    int (*tclBN_mp_mod) (const mp_int *a, const mp_int *b, mp_int *r); /* 27 */
     int (*tclBN_mp_mod_2d) (const mp_int *a, int b, mp_int *r); /* 28 */
-    int (*tclBN_mp_mul) (mp_int *a, mp_int *b, mp_int *p); /* 29 */
-    int (*tclBN_mp_mul_d) (mp_int *a, mp_digit b, mp_int *p); /* 30 */
-    int (*tclBN_mp_mul_2) (mp_int *a, mp_int *p); /* 31 */
+    int (*tclBN_mp_mul) (const mp_int *a, const mp_int *b, mp_int *p); /* 29 */
+    int (*tclBN_mp_mul_d) (const mp_int *a, mp_digit b, mp_int *p); /* 30 */
+    int (*tclBN_mp_mul_2) (const mp_int *a, mp_int *p); /* 31 */
     int (*tclBN_mp_mul_2d) (const mp_int *a, int d, mp_int *p); /* 32 */
     int (*tclBN_mp_neg) (const mp_int *a, mp_int *b); /* 33 */
-    int (*tclBN_mp_or) (mp_int *a, mp_int *b, mp_int *c); /* 34 */
-    int (*tclBN_mp_radix_size) (mp_int *a, int radix, int *size); /* 35 */
+    int (*tclBN_mp_or) (const mp_int *a, const mp_int *b, mp_int *c); /* 34 */
+    int (*tclBN_mp_radix_size) (const mp_int *a, int radix, int *size); /* 35 */
     int (*tclBN_mp_read_radix) (mp_int *a, const char *str, int radix); /* 36 */
     void (*tclBN_mp_rshd) (mp_int *a, int shift); /* 37 */
     int (*tclBN_mp_shrink) (mp_int *a); /* 38 */
     void (*tclBN_mp_set) (mp_int *a, mp_digit b); /* 39 */
-    int (*tclBN_mp_sqr) (mp_int *a, mp_int *b); /* 40 */
-    int (*tclBN_mp_sqrt) (mp_int *a, mp_int *b); /* 41 */
-    int (*tclBN_mp_sub) (mp_int *a, mp_int *b, mp_int *c); /* 42 */
-    int (*tclBN_mp_sub_d) (mp_int *a, mp_digit b, mp_int *c); /* 43 */
-    int (*tclBN_mp_to_unsigned_bin) (mp_int *a, unsigned char *b); /* 44 */
-    int (*tclBN_mp_to_unsigned_bin_n) (mp_int *a, unsigned char *b, unsigned long *outlen); /* 45 */
-    int (*tclBN_mp_toradix_n) (mp_int *a, char *str, int radix, int maxlen); /* 46 */
-    int (*tclBN_mp_unsigned_bin_size) (mp_int *a); /* 47 */
-    int (*tclBN_mp_xor) (mp_int *a, mp_int *b, mp_int *c); /* 48 */
+    int (*tclBN_mp_sqr) (const mp_int *a, mp_int *b); /* 40 */
+    int (*tclBN_mp_sqrt) (const mp_int *a, mp_int *b); /* 41 */
+    int (*tclBN_mp_sub) (const mp_int *a, const mp_int *b, mp_int *c); /* 42 */
+    int (*tclBN_mp_sub_d) (const mp_int *a, mp_digit b, mp_int *c); /* 43 */
+    int (*tclBN_mp_to_unsigned_bin) (const mp_int *a, unsigned char *b); /* 44 */
+    int (*tclBN_mp_to_unsigned_bin_n) (const mp_int *a, unsigned char *b, unsigned long *outlen); /* 45 */
+    int (*tclBN_mp_toradix_n) (const mp_int *a, char *str, int radix, int maxlen); /* 46 */
+    int (*tclBN_mp_unsigned_bin_size) (const mp_int *a); /* 47 */
+    int (*tclBN_mp_xor) (const mp_int *a, const mp_int *b, mp_int *c); /* 48 */
     void (*tclBN_mp_zero) (mp_int *a); /* 49 */
     void (*tclBN_reverse) (unsigned char *s, int len); /* 50 */
-    int (*tclBN_fast_s_mp_mul_digs) (mp_int *a, mp_int *b, mp_int *c, int digs); /* 51 */
-    int (*tclBN_fast_s_mp_sqr) (mp_int *a, mp_int *b); /* 52 */
-    int (*tclBN_mp_karatsuba_mul) (mp_int *a, mp_int *b, mp_int *c); /* 53 */
-    int (*tclBN_mp_karatsuba_sqr) (mp_int *a, mp_int *b); /* 54 */
-    int (*tclBN_mp_toom_mul) (mp_int *a, mp_int *b, mp_int *c); /* 55 */
-    int (*tclBN_mp_toom_sqr) (mp_int *a, mp_int *b); /* 56 */
-    int (*tclBN_s_mp_add) (mp_int *a, mp_int *b, mp_int *c); /* 57 */
-    int (*tclBN_s_mp_mul_digs) (mp_int *a, mp_int *b, mp_int *c, int digs); /* 58 */
-    int (*tclBN_s_mp_sqr) (mp_int *a, mp_int *b); /* 59 */
-    int (*tclBN_s_mp_sub) (mp_int *a, mp_int *b, mp_int *c); /* 60 */
+    int (*tclBN_fast_s_mp_mul_digs) (const mp_int *a, const mp_int *b, mp_int *c, int digs); /* 51 */
+    int (*tclBN_fast_s_mp_sqr) (const mp_int *a, mp_int *b); /* 52 */
+    int (*tclBN_mp_karatsuba_mul) (const mp_int *a, const mp_int *b, mp_int *c); /* 53 */
+    int (*tclBN_mp_karatsuba_sqr) (const mp_int *a, mp_int *b); /* 54 */
+    int (*tclBN_mp_toom_mul) (const mp_int *a, const mp_int *b, mp_int *c); /* 55 */
+    int (*tclBN_mp_toom_sqr) (const mp_int *a, mp_int *b); /* 56 */
+    int (*tclBN_s_mp_add) (const mp_int *a, const mp_int *b, mp_int *c); /* 57 */
+    int (*tclBN_s_mp_mul_digs) (const mp_int *a, const mp_int *b, mp_int *c, int digs); /* 58 */
+    int (*tclBN_s_mp_sqr) (const mp_int *a, mp_int *b); /* 59 */
+    int (*tclBN_s_mp_sub) (const mp_int *a, const mp_int *b, mp_int *c); /* 60 */
     int (*tclBN_mp_init_set_int) (mp_int *a, unsigned long i); /* 61 */
     int (*tclBN_mp_set_int) (mp_int *a, unsigned long i); /* 62 */
     int (*tclBN_mp_cnt_lsb) (const mp_int *a); /* 63 */
     void (*tclBNInitBignumFromLong) (mp_int *bignum, long initVal); /* 64 */
     void (*tclBNInitBignumFromWideInt) (mp_int *bignum, Tcl_WideInt initVal); /* 65 */
     void (*tclBNInitBignumFromWideUInt) (mp_int *bignum, Tcl_WideUInt initVal); /* 66 */
+    int (*tclBN_mp_expt_d_ex) (const mp_int *a, mp_digit b, mp_int *c, int fast); /* 67 */
 } TclTomMathStubs;
 
 extern const TclTomMathStubs *tclTomMathStubsPtr;
@@ -507,6 +528,8 @@ extern const TclTomMathStubs *tclTomMathStubsPtr;
 	(tclTomMathStubsPtr->tclBNInitBignumFromWideInt) /* 65 */
 #define TclBNInitBignumFromWideUInt \
 	(tclTomMathStubsPtr->tclBNInitBignumFromWideUInt) /* 66 */
+#define TclBN_mp_expt_d_ex \
+	(tclTomMathStubsPtr->tclBN_mp_expt_d_ex) /* 67 */
 
 #endif /* defined(USE_TCL_STUBS) */