This is part 2 of 4, this also fixes some x64 errors, warnings and allow you to build a full debug unicode

huuuuuge tipo fixes
warning fixed (not all but many for this time)
Prepare for a gpg-error change
Support of ia32 AES instructions
gpg error change
Msvc compiler fixes
Allow transient-key for ecdsa (würg-grund :D )
spelling fixes
added new trigger events
add a entropy gatherer for W32CE and some other stuff
gcc fixes
boooooooooooooost performance of SHA-512 and SHA-256 ...

unfortunately that is all ;( ..... some work i'll be add maybe later this week 

git-svn-id: http://mirotr.googlecode.com/svn/trunk@38 eced67a3-f377-a0ae-92ae-d6de1850b05a

6 files changed, 3645 insertions, 3647 deletions

diff --git a/libgcrypt-1.4.6/mpi/longlong.h b/libgcrypt-1.4.6/mpi/longlong.h
index b736d49..586c4cc 100644
--- a/libgcrypt-1.4.6/mpi/longlong.h
+++ b/libgcrypt-1.4.6/mpi/longlong.h
@@ -1,1578 +1,1578 @@
-/* longlong.h -- definitions for mixed size 32/64 bit arithmetic.
-   Note: I added some stuff for use with gnupg
-
-Copyright (C) 1991, 1992, 1993, 1994, 1996, 1998,
-              2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
-
-This file is free software; you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2.1 of the License, or (at your
-option) any later version.
-
-This file is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-License for more details.
-
-You should have received a copy of the GNU Library General Public License
-along with this file; see the file COPYING.LIB.  If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-MA 02111-1307, USA. */
-
-/* You have to define the following before including this file:
-
-   UWtype -- An unsigned type, default type for operations (typically a "word")
-   UHWtype -- An unsigned type, at least half the size of UWtype.
-   UDWtype -- An unsigned type, at least twice as large a UWtype
-   W_TYPE_SIZE -- size in bits of UWtype
-
-   SItype, USItype -- Signed and unsigned 32 bit types.
-   DItype, UDItype -- Signed and unsigned 64 bit types.
-
-   On a 32 bit machine UWtype should typically be USItype;
-   on a 64 bit machine, UWtype should typically be UDItype.
-*/
-
-#define __BITS4 (W_TYPE_SIZE / 4)
-#define __ll_B ((UWtype) 1 << (W_TYPE_SIZE / 2))
-#define __ll_lowpart(t) ((UWtype) (t) & (__ll_B - 1))
-#define __ll_highpart(t) ((UWtype) (t) >> (W_TYPE_SIZE / 2))
-
-/* This is used to make sure no undesirable sharing between different libraries
-   that use this file takes place.  */
-#ifndef __MPN
-#define __MPN(x) __##x
-#endif
-
-/* Define auxiliary asm macros.
-
-   1) umul_ppmm(high_prod, low_prod, multipler, multiplicand) multiplies two
-   UWtype integers MULTIPLER and MULTIPLICAND, and generates a two UWtype
-   word product in HIGH_PROD and LOW_PROD.
-
-   2) __umulsidi3(a,b) multiplies two UWtype integers A and B, and returns a
-   UDWtype product.  This is just a variant of umul_ppmm.
-
-   3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
-   denominator) divides a UDWtype, composed by the UWtype integers
-   HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient
-   in QUOTIENT and the remainder in REMAINDER.	HIGH_NUMERATOR must be less
-   than DENOMINATOR for correct operation.  If, in addition, the most
-   significant bit of DENOMINATOR must be 1, then the pre-processor symbol
-   UDIV_NEEDS_NORMALIZATION is defined to 1.
-
-   4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,
-   denominator).  Like udiv_qrnnd but the numbers are signed.  The quotient
-   is rounded towards 0.
-
-   5) count_leading_zeros(count, x) counts the number of zero-bits from the
-   msb to the first non-zero bit in the UWtype X.  This is the number of
-   steps X needs to be shifted left to set the msb.  Undefined for X == 0,
-   unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value.
-
-   6) count_trailing_zeros(count, x) like count_leading_zeros, but counts
-   from the least significant end.
-
-   7) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,
-   high_addend_2, low_addend_2) adds two UWtype integers, composed by
-   HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2
-   respectively.  The result is placed in HIGH_SUM and LOW_SUM.  Overflow
-   (i.e. carry out) is not stored anywhere, and is lost.
-
-   8) sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,
-   high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,
-   composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and
-   LOW_SUBTRAHEND_2 respectively.  The result is placed in HIGH_DIFFERENCE
-   and LOW_DIFFERENCE.	Overflow (i.e. carry out) is not stored anywhere,
-   and is lost.
-
-   If any of these macros are left undefined for a particular CPU,
-   C macros are used.  */
-
-/* The CPUs come in alphabetical order below.
-
-   Please add support for more CPUs here, or improve the current support
-   for the CPUs below!	*/
-
-#ifdef __riscos__
-#pragma continue_after_hash_error
-#else /* !__riscos__ */
-#if defined (__GNUC__) && !defined (NO_ASM)
-
-/* We sometimes need to clobber "cc" with gcc2, but that would not be
-   understood by gcc1.	Use cpp to avoid major code duplication.  */
-#if __GNUC__ < 2
-#define __CLOBBER_CC
-#define __AND_CLOBBER_CC
-#else /* __GNUC__ >= 2 */
-#define __CLOBBER_CC : "cc"
-#define __AND_CLOBBER_CC , "cc"
-#endif /* __GNUC__ < 2 */
-
-
-/***************************************
- **************  A29K  *****************
- ***************************************/
-#if (defined (__a29k__) || defined (_AM29K)) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("add %1,%4,%5\n"   \
-           "addc %0,%2,%3"                                              \
-	   : "=r" ((USItype)(sh)),                                      \
-	    "=&r" ((USItype)(sl))                                       \
-	   : "%r" ((USItype)(ah)),                                      \
-	     "rI" ((USItype)(bh)),                                      \
-	     "%r" ((USItype)(al)),                                      \
-	     "rI" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("sub %1,%4,%5\n"                                             \
-	   "subc %0,%2,%3"                                              \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "r" ((USItype)(ah)),                                       \
-	     "rI" ((USItype)(bh)),                                      \
-	     "r" ((USItype)(al)),                                       \
-	     "rI" ((USItype)(bl)))
-#define umul_ppmm(xh, xl, m0, m1) \
-  do {									\
-    USItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("multiplu %0,%1,%2"                                        \
-	     : "=r" ((USItype)(xl))                                     \
-	     : "r" (__m0),                                              \
-	       "r" (__m1));                                             \
-    __asm__ ("multmu %0,%1,%2"                                          \
-	     : "=r" ((USItype)(xh))                                     \
-	     : "r" (__m0),                                              \
-	       "r" (__m1));                                             \
-  } while (0)
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  __asm__ ("dividu %0,%3,%4"                                            \
-	   : "=r" ((USItype)(q)),                                       \
-	     "=q" ((USItype)(r))                                        \
-	   : "1" ((USItype)(n1)),                                       \
-	     "r" ((USItype)(n0)),                                       \
-	     "r" ((USItype)(d)))
-#define count_leading_zeros(count, x) \
-    __asm__ ("clz %0,%1"                                                \
-	     : "=r" ((USItype)(count))                                  \
-	     : "r" ((USItype)(x)))
-#define COUNT_LEADING_ZEROS_0 32
-#endif /* __a29k__ */
-
-
-#if defined (__alpha) && W_TYPE_SIZE == 64
-#define umul_ppmm(ph, pl, m0, m1) \
-  do {									\
-    UDItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("umulh %r1,%2,%0"                                          \
-	     : "=r" ((UDItype) ph)                                      \
-	     : "%rJ" (__m0),                                            \
-	       "rI" (__m1));                                            \
-    (pl) = __m0 * __m1; 						\
-  } while (0)
-#define UMUL_TIME 46
-#ifndef LONGLONG_STANDALONE
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  do { UDItype __r;							\
-    (q) = __udiv_qrnnd (&__r, (n1), (n0), (d)); 			\
-    (r) = __r;								\
-  } while (0)
-extern UDItype __udiv_qrnnd ();
-#define UDIV_TIME 220
-#endif /* LONGLONG_STANDALONE */
-#endif /* __alpha */
-
-/***************************************
- **************  ARM  ******************
- ***************************************/
-#if defined (__arm__) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("adds %1, %4, %5\n"                                          \
-	   "adc  %0, %2, %3"                                            \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%r" ((USItype)(ah)),                                      \
-	     "rI" ((USItype)(bh)),                                      \
-	     "%r" ((USItype)(al)),                                      \
-	     "rI" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("subs %1, %4, %5\n"                                          \
-	   "sbc  %0, %2, %3"                                            \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "r" ((USItype)(ah)),                                       \
-	     "rI" ((USItype)(bh)),                                      \
-	     "r" ((USItype)(al)),                                       \
-	     "rI" ((USItype)(bl)))
-#if defined __ARM_ARCH_2__ || defined __ARM_ARCH_3__
-#define umul_ppmm(xh, xl, a, b) \
-  __asm__ ("%@ Inlined umul_ppmm\n"                                     \
-	"mov	%|r0, %2, lsr #16		@ AAAA\n"               \
-	"mov	%|r2, %3, lsr #16		@ BBBB\n"               \
-	"bic	%|r1, %2, %|r0, lsl #16		@ aaaa\n"               \
-	"bic	%0, %3, %|r2, lsl #16		@ bbbb\n"               \
-	"mul	%1, %|r1, %|r2			@ aaaa * BBBB\n"        \
-	"mul	%|r2, %|r0, %|r2		@ AAAA * BBBB\n"        \
-	"mul	%|r1, %0, %|r1			@ aaaa * bbbb\n"        \
-	"mul	%0, %|r0, %0			@ AAAA * bbbb\n"        \
-	"adds	%|r0, %1, %0			@ central sum\n"        \
-	"addcs	%|r2, %|r2, #65536\n"                                   \
-	"adds	%1, %|r1, %|r0, lsl #16\n"                              \
-	"adc	%0, %|r2, %|r0, lsr #16"                                \
-	   : "=&r" ((USItype)(xh)),                                     \
-	     "=r" ((USItype)(xl))                                       \
-	   : "r" ((USItype)(a)),                                        \
-	     "r" ((USItype)(b))                                         \
-	   : "r0", "r1", "r2")
-#else
-#define umul_ppmm(xh, xl, a, b)                                         \
-  __asm__ ("%@ Inlined umul_ppmm\n"                                     \
-	   "umull %r1, %r0, %r2, %r3"                                   \
-		   : "=&r" ((USItype)(xh)),                             \
-		     "=r" ((USItype)(xl))                               \
-		   : "r" ((USItype)(a)),                                \
-		     "r" ((USItype)(b))                                 \
-		   : "r0", "r1")
-#endif
-#define UMUL_TIME 20
-#define UDIV_TIME 100
-#endif /* __arm__ */
-
-/***************************************
- **************  CLIPPER  **************
- ***************************************/
-#if defined (__clipper__) && W_TYPE_SIZE == 32
-#define umul_ppmm(w1, w0, u, v) \
-  ({union {UDItype __ll;						\
-	   struct {USItype __l, __h;} __i;				\
-	  } __xx;							\
-  __asm__ ("mulwux %2,%0"                                               \
-	   : "=r" (__xx.__ll)                                           \
-	   : "%0" ((USItype)(u)),                                       \
-	     "r" ((USItype)(v)));                                       \
-  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
-#define smul_ppmm(w1, w0, u, v) \
-  ({union {DItype __ll; 						\
-	   struct {SItype __l, __h;} __i;				\
-	  } __xx;							\
-  __asm__ ("mulwx %2,%0"                                                \
-	   : "=r" (__xx.__ll)                                           \
-	   : "%0" ((SItype)(u)),                                        \
-	     "r" ((SItype)(v)));                                        \
-  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
-#define __umulsidi3(u, v) \
-  ({UDItype __w;							\
-    __asm__ ("mulwux %2,%0"                                             \
-	     : "=r" (__w)                                               \
-	     : "%0" ((USItype)(u)),                                     \
-	       "r" ((USItype)(v)));                                     \
-    __w; })
-#endif /* __clipper__ */
-
-
-/***************************************
- **************  GMICRO  ***************
- ***************************************/
-#if defined (__gmicro__) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("add.w %5,%1\n"                                              \
-	   "addx %3,%0"                                                 \
-	   : "=g" ((USItype)(sh)),                                      \
-	     "=&g" ((USItype)(sl))                                      \
-	   : "%0" ((USItype)(ah)),                                      \
-	     "g" ((USItype)(bh)),                                       \
-	     "%1" ((USItype)(al)),                                      \
-	     "g" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("sub.w %5,%1\n"                                              \
-	   "subx %3,%0"                                                 \
-	   : "=g" ((USItype)(sh)),                                      \
-	     "=&g" ((USItype)(sl))                                      \
-	   : "0" ((USItype)(ah)),                                       \
-	     "g" ((USItype)(bh)),                                       \
-	     "1" ((USItype)(al)),                                       \
-	     "g" ((USItype)(bl)))
-#define umul_ppmm(ph, pl, m0, m1) \
-  __asm__ ("mulx %3,%0,%1"                                              \
-	   : "=g" ((USItype)(ph)),                                      \
-	     "=r" ((USItype)(pl))                                       \
-	   : "%0" ((USItype)(m0)),                                      \
-	     "g" ((USItype)(m1)))
-#define udiv_qrnnd(q, r, nh, nl, d) \
-  __asm__ ("divx %4,%0,%1"                                              \
-	   : "=g" ((USItype)(q)),                                       \
-	     "=r" ((USItype)(r))                                        \
-	   : "1" ((USItype)(nh)),                                       \
-	     "0" ((USItype)(nl)),                                       \
-	     "g" ((USItype)(d)))
-#define count_leading_zeros(count, x) \
-  __asm__ ("bsch/1 %1,%0"                                               \
-	   : "=g" (count)                                               \
-	   : "g" ((USItype)(x)),                                        \
-	     "0" ((USItype)0))
-#endif
-
-
-/***************************************
- **************  HPPA  *****************
- ***************************************/
-#if defined (__hppa) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("	add %4,%5,%1\n"                                             \
- 	   "	addc %2,%3,%0"                                              \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%rM" ((USItype)(ah)),                                     \
-	     "rM" ((USItype)(bh)),                                      \
-	     "%rM" ((USItype)(al)),                                     \
-	     "rM" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("	sub %4,%5,%1\n"                                             \
-	   "	subb %2,%3,%0"                                              \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "rM" ((USItype)(ah)),                                      \
-	     "rM" ((USItype)(bh)),                                      \
-	     "rM" ((USItype)(al)),                                      \
-	     "rM" ((USItype)(bl)))
-#if defined (_PA_RISC1_1)
-#define umul_ppmm(wh, wl, u, v) \
-  do {									\
-    union {UDItype __ll;						\
-	   struct {USItype __h, __l;} __i;				\
-	  } __xx;							\
-    __asm__ ("	xmpyu %1,%2,%0"                                           \
-	     : "=*f" (__xx.__ll)                                        \
-	     : "*f" ((USItype)(u)),                                     \
-	       "*f" ((USItype)(v)));                                    \
-    (wh) = __xx.__i.__h;						\
-    (wl) = __xx.__i.__l;						\
-  } while (0)
-#define UMUL_TIME 8
-#define UDIV_TIME 60
-#else
-#define UMUL_TIME 40
-#define UDIV_TIME 80
-#endif
-#ifndef LONGLONG_STANDALONE
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  do { USItype __r;							\
-    (q) = __udiv_qrnnd (&__r, (n1), (n0), (d)); 			\
-    (r) = __r;								\
-  } while (0)
-extern USItype __udiv_qrnnd ();
-#endif /* LONGLONG_STANDALONE */
-#define count_leading_zeros(count, x) \
-  do {								       \
-    USItype __tmp;						       \
-    __asm__ (				                               \
-       "	ldi             1,%0                                       \n" \
-       "	extru,= 	%1,15,16,%%r0  ; Bits 31..16 zero?         \n" \
-       "	extru,tr	%1,15,16,%1    ; No.  Shift down, skip add.\n" \
-       "	ldo		16(%0),%0      ; Yes.	Perform add.       \n" \
-       "	extru,= 	%1,23,8,%%r0   ; Bits 15..8 zero?          \n" \
-       "	extru,tr	%1,23,8,%1     ; No.  Shift down, skip add.\n" \
-       "	ldo		8(%0),%0       ; Yes.	Perform add.       \n" \
-       "	extru,= 	%1,27,4,%%r0   ; Bits 7..4 zero?           \n" \
-       "	extru,tr	%1,27,4,%1     ; No.  Shift down, skip add.\n" \
-       "	ldo		4(%0),%0       ; Yes.	Perform add.       \n" \
-       "	extru,= 	%1,29,2,%%r0   ; Bits 3..2 zero?           \n" \
-       "	extru,tr	%1,29,2,%1     ; No.  Shift down, skip add.\n" \
-       "	ldo		2(%0),%0       ; Yes.	Perform add.       \n" \
-       "	extru		%1,30,1,%1     ; Extract bit 1.            \n" \
-       "	sub		%0,%1,%0       ; Subtract it.              "   \
-       : "=r" (count), "=r" (__tmp) : "1" (x));                        \
-  } while (0)
-#endif /* hppa */
-
-
-/***************************************
- **************  I370  *****************
- ***************************************/
-#if (defined (__i370__) || defined (__mvs__)) && W_TYPE_SIZE == 32
-#define umul_ppmm(xh, xl, m0, m1) \
-  do {									\
-    union {UDItype __ll;						\
-	   struct {USItype __h, __l;} __i;				\
-	  } __xx;							\
-    USItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("mr %0,%3"                                                 \
-	     : "=r" (__xx.__i.__h),                                     \
-	       "=r" (__xx.__i.__l)                                      \
-	     : "%1" (__m0),                                             \
-	       "r" (__m1));                                             \
-    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\
-    (xh) += ((((SItype) __m0 >> 31) & __m1)				\
-	     + (((SItype) __m1 >> 31) & __m0)); 			\
-  } while (0)
-#define smul_ppmm(xh, xl, m0, m1) \
-  do {									\
-    union {DItype __ll; 						\
-	   struct {USItype __h, __l;} __i;				\
-	  } __xx;							\
-    __asm__ ("mr %0,%3"                                                 \
-	     : "=r" (__xx.__i.__h),                                     \
-	       "=r" (__xx.__i.__l)                                      \
-	     : "%1" (m0),                                               \
-	       "r" (m1));                                               \
-    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\
-  } while (0)
-#define sdiv_qrnnd(q, r, n1, n0, d) \
-  do {									\
-    union {DItype __ll; 						\
-	   struct {USItype __h, __l;} __i;				\
-	  } __xx;							\
-    __xx.__i.__h = n1; __xx.__i.__l = n0;				\
-    __asm__ ("dr %0,%2"                                                 \
-	     : "=r" (__xx.__ll)                                         \
-	     : "0" (__xx.__ll), "r" (d));                               \
-    (q) = __xx.__i.__l; (r) = __xx.__i.__h;				\
-  } while (0)
-#endif
-
-
-/***************************************
- **************  I386  *****************
- ***************************************/
-#if (defined (__i386__) || defined (__i486__)) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("addl %5,%1\n"                                               \
-	   "adcl %3,%0"                                                 \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%0" ((USItype)(ah)),                                      \
-	     "g" ((USItype)(bh)),                                       \
-	     "%1" ((USItype)(al)),                                      \
-	     "g" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("subl %5,%1\n"                                               \
-	   "sbbl %3,%0"                                                 \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "0" ((USItype)(ah)),                                       \
-	     "g" ((USItype)(bh)),                                       \
-	     "1" ((USItype)(al)),                                       \
-	     "g" ((USItype)(bl)))
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("mull %3"                                                    \
-	   : "=a" ((USItype)(w0)),                                      \
-	     "=d" ((USItype)(w1))                                       \
-	   : "%0" ((USItype)(u)),                                       \
-	     "rm" ((USItype)(v)))
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  __asm__ ("divl %4"                                                    \
-	   : "=a" ((USItype)(q)),                                       \
-	     "=d" ((USItype)(r))                                        \
-	   : "0" ((USItype)(n0)),                                       \
-	     "1" ((USItype)(n1)),                                       \
-	     "rm" ((USItype)(d)))
-#define count_leading_zeros(count, x) \
-  do {									\
-    USItype __cbtmp;							\
-    __asm__ ("bsrl %1,%0"                                               \
-	     : "=r" (__cbtmp) : "rm" ((USItype)(x)));                   \
-    (count) = __cbtmp ^ 31;						\
-  } while (0)
-#define count_trailing_zeros(count, x) \
-  __asm__ ("bsfl %1,%0" : "=r" (count) : "rm" ((USItype)(x)))
-#ifndef UMUL_TIME
-#define UMUL_TIME 40
-#endif
-#ifndef UDIV_TIME
-#define UDIV_TIME 40
-#endif
-#endif /* 80x86 */
-
-
-/***************************************
- **************  I860  *****************
- ***************************************/
-#if defined (__i860__) && W_TYPE_SIZE == 32
-#define rshift_rhlc(r,h,l,c) \
-  __asm__ ("shr %3,r0,r0\n"  \
-           "shrd %1,%2,%0"   \
-	   "=r" (r) : "r" (h), "r" (l), "rn" (c))
-#endif /* i860 */
-
-/***************************************
- **************  I960  *****************
- ***************************************/
-#if defined (__i960__) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("cmpo 1,0\n"      \
-           "addc %5,%4,%1\n" \
-           "addc %3,%2,%0"   \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%dI" ((USItype)(ah)),                                     \
-	     "dI" ((USItype)(bh)),                                      \
-	     "%dI" ((USItype)(al)),                                     \
-	     "dI" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("cmpo 0,0\n"      \
-           "subc %5,%4,%1\n" \
-           "subc %3,%2,%0"   \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "dI" ((USItype)(ah)),                                      \
-	     "dI" ((USItype)(bh)),                                      \
-	     "dI" ((USItype)(al)),                                      \
-	     "dI" ((USItype)(bl)))
-#define umul_ppmm(w1, w0, u, v) \
-  ({union {UDItype __ll;						\
-	   struct {USItype __l, __h;} __i;				\
-	  } __xx;							\
-  __asm__ ("emul        %2,%1,%0"                                       \
-	   : "=d" (__xx.__ll)                                           \
-	   : "%dI" ((USItype)(u)),                                      \
-	     "dI" ((USItype)(v)));                                      \
-  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
-#define __umulsidi3(u, v) \
-  ({UDItype __w;							\
-    __asm__ ("emul      %2,%1,%0"                                       \
-	     : "=d" (__w)                                               \
-	     : "%dI" ((USItype)(u)),                                    \
-	       "dI" ((USItype)(v)));                                    \
-    __w; })
-#define udiv_qrnnd(q, r, nh, nl, d) \
-  do {									\
-    union {UDItype __ll;						\
-	   struct {USItype __l, __h;} __i;				\
-	  } __nn;							\
-    __nn.__i.__h = (nh); __nn.__i.__l = (nl);				\
-    __asm__ ("ediv %d,%n,%0"                                            \
-	   : "=d" (__rq.__ll)                                           \
-	   : "dI" (__nn.__ll),                                          \
-	     "dI" ((USItype)(d)));                                      \
-    (r) = __rq.__i.__l; (q) = __rq.__i.__h;				\
-  } while (0)
-#define count_leading_zeros(count, x) \
-  do {									\
-    USItype __cbtmp;							\
-    __asm__ ("scanbit %1,%0"                                            \
-	     : "=r" (__cbtmp)                                           \
-	     : "r" ((USItype)(x)));                                     \
-    (count) = __cbtmp ^ 31;						\
-  } while (0)
-#define COUNT_LEADING_ZEROS_0 (-32) /* sic */
-#if defined (__i960mx)		/* what is the proper symbol to test??? */
-#define rshift_rhlc(r,h,l,c) \
-  do {									\
-    union {UDItype __ll;						\
-	   struct {USItype __l, __h;} __i;				\
-	  } __nn;							\
-    __nn.__i.__h = (h); __nn.__i.__l = (l);				\
-    __asm__ ("shre %2,%1,%0"                                            \
-	     : "=d" (r) : "dI" (__nn.__ll), "dI" (c));                  \
-  }
-#endif /* i960mx */
-#endif /* i960 */
-
-
-/***************************************
- **************  68000	****************
- ***************************************/
-#if (defined (__mc68000__) || defined (__mc68020__) || defined (__NeXT__) || defined(mc68020)) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("add%.l %5,%1\n"                                             \
-	   "addx%.l %3,%0"                                              \
-	   : "=d" ((USItype)(sh)),                                      \
-	     "=&d" ((USItype)(sl))                                      \
-	   : "%0" ((USItype)(ah)),                                      \
-	     "d" ((USItype)(bh)),                                       \
-	     "%1" ((USItype)(al)),                                      \
-	     "g" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("sub%.l %5,%1\n"                                             \
-	   "subx%.l %3,%0"                                              \
-	   : "=d" ((USItype)(sh)),                                      \
-	     "=&d" ((USItype)(sl))                                      \
-	   : "0" ((USItype)(ah)),                                       \
-	     "d" ((USItype)(bh)),                                       \
-	     "1" ((USItype)(al)),                                       \
-	     "g" ((USItype)(bl)))
-#if (defined (__mc68020__) || defined (__NeXT__) || defined(mc68020))
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("mulu%.l %3,%1:%0"                                           \
-	   : "=d" ((USItype)(w0)),                                      \
-	     "=d" ((USItype)(w1))                                       \
-	   : "%0" ((USItype)(u)),                                       \
-	     "dmi" ((USItype)(v)))
-#define UMUL_TIME 45
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  __asm__ ("divu%.l %4,%1:%0"                                           \
-	   : "=d" ((USItype)(q)),                                       \
-	     "=d" ((USItype)(r))                                        \
-	   : "0" ((USItype)(n0)),                                       \
-	     "1" ((USItype)(n1)),                                       \
-	     "dmi" ((USItype)(d)))
-#define UDIV_TIME 90
-#define sdiv_qrnnd(q, r, n1, n0, d) \
-  __asm__ ("divs%.l %4,%1:%0"                                           \
-	   : "=d" ((USItype)(q)),                                       \
-	     "=d" ((USItype)(r))                                        \
-	   : "0" ((USItype)(n0)),                                       \
-	     "1" ((USItype)(n1)),                                       \
-	     "dmi" ((USItype)(d)))
-#define count_leading_zeros(count, x) \
-  __asm__ ("bfffo %1{%b2:%b2},%0"                                       \
-	   : "=d" ((USItype)(count))                                    \
-	   : "od" ((USItype)(x)), "n" (0))
-#define COUNT_LEADING_ZEROS_0 32
-#else /* not mc68020 */
-#define umul_ppmm(xh, xl, a, b) \
-  do { USItype __umul_tmp1, __umul_tmp2;			  \
-	__asm__ ("| Inlined umul_ppmm                         \n" \
- "        move%.l %5,%3                                       \n" \
- "        move%.l %2,%0                                       \n" \
- "        move%.w %3,%1                                       \n" \
- "        swap	%3                                            \n" \
- "        swap	%0                                            \n" \
- "        mulu	%2,%1                                         \n" \
- "        mulu	%3,%0                                         \n" \
- "        mulu	%2,%3                                         \n" \
- "        swap	%2                                            \n" \
- "        mulu	%5,%2                                         \n" \
- "        add%.l	%3,%2                                 \n" \
- "        jcc	1f                                            \n" \
- "        add%.l	%#0x10000,%0                          \n" \
- "1:	move%.l %2,%3                                         \n" \
- "        clr%.w	%2                                    \n" \
- "        swap	%2                                            \n" \
- "        swap	%3                                            \n" \
- "        clr%.w	%3                                    \n" \
- "        add%.l	%3,%1                                 \n" \
- "        addx%.l %2,%0                                       \n" \
- "        | End inlined umul_ppmm"                                \
-	      : "=&d" ((USItype)(xh)), "=&d" ((USItype)(xl)),     \
-		"=d" (__umul_tmp1), "=&d" (__umul_tmp2)           \
-	      : "%2" ((USItype)(a)), "d" ((USItype)(b)));         \
-  } while (0)
-#define UMUL_TIME 100
-#define UDIV_TIME 400
-#endif /* not mc68020 */
-#endif /* mc68000 */
-
-
-/***************************************
- **************  88000	****************
- ***************************************/
-#if defined (__m88000__) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("addu.co %1,%r4,%r5\n"                                       \
-	   "addu.ci %0,%r2,%r3"                                         \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%rJ" ((USItype)(ah)),                                     \
-	     "rJ" ((USItype)(bh)),                                      \
-	     "%rJ" ((USItype)(al)),                                     \
-	     "rJ" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("subu.co %1,%r4,%r5\n"                                       \
-	   "subu.ci %0,%r2,%r3"                                         \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "rJ" ((USItype)(ah)),                                      \
-	     "rJ" ((USItype)(bh)),                                      \
-	     "rJ" ((USItype)(al)),                                      \
-	     "rJ" ((USItype)(bl)))
-#define count_leading_zeros(count, x) \
-  do {									\
-    USItype __cbtmp;							\
-    __asm__ ("ff1 %0,%1"                                                \
-	     : "=r" (__cbtmp)                                           \
-	     : "r" ((USItype)(x)));                                     \
-    (count) = __cbtmp ^ 31;						\
-  } while (0)
-#define COUNT_LEADING_ZEROS_0 63 /* sic */
-#if defined (__m88110__)
-#define umul_ppmm(wh, wl, u, v) \
-  do {									\
-    union {UDItype __ll;						\
-	   struct {USItype __h, __l;} __i;				\
-	  } __x;							\
-    __asm__ ("mulu.d %0,%1,%2" : "=r" (__x.__ll) : "r" (u), "r" (v));   \
-    (wh) = __x.__i.__h; 						\
-    (wl) = __x.__i.__l; 						\
-  } while (0)
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  ({union {UDItype __ll;						\
-	   struct {USItype __h, __l;} __i;				\
-	  } __x, __q;							\
-  __x.__i.__h = (n1); __x.__i.__l = (n0);				\
-  __asm__ ("divu.d %0,%1,%2"                                            \
-	   : "=r" (__q.__ll) : "r" (__x.__ll), "r" (d));                \
-  (r) = (n0) - __q.__l * (d); (q) = __q.__l; })
-#define UMUL_TIME 5
-#define UDIV_TIME 25
-#else
-#define UMUL_TIME 17
-#define UDIV_TIME 150
-#endif /* __m88110__ */
-#endif /* __m88000__ */
-
-/***************************************
- **************  MIPS  *****************
- ***************************************/
-#if defined (__mips__) && W_TYPE_SIZE == 32
-#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
-#define umul_ppmm(w1, w0, u, v) \
-  do {                                                                  \
-    UDItype _r;                                                         \
-    _r = (UDItype) u * v;                                               \
-    (w1) = _r >> 32;                                                    \
-    (w0) = (USItype) _r;                                                \
-  } while (0)
-#elif __GNUC__ > 2 || __GNUC_MINOR__ >= 7
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("multu %2,%3"                                                \
-	   : "=l" ((USItype)(w0)),                                      \
-	     "=h" ((USItype)(w1))                                       \
-	   : "d" ((USItype)(u)),                                        \
-	     "d" ((USItype)(v)))
-#else
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("multu %2,%3 \n" \
-	   "mflo %0 \n"     \
-	   "mfhi %1"                                                        \
-	   : "=d" ((USItype)(w0)),                                      \
-	     "=d" ((USItype)(w1))                                       \
-	   : "d" ((USItype)(u)),                                        \
-	     "d" ((USItype)(v)))
-#endif
-#define UMUL_TIME 10
-#define UDIV_TIME 100
-#endif /* __mips__ */
-
-/***************************************
- **************  MIPS/64  **************
- ***************************************/
-#if (defined (__mips) && __mips >= 3) && W_TYPE_SIZE == 64
-#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
-typedef unsigned int UTItype __attribute__ ((mode (TI)));
-#define umul_ppmm(w1, w0, u, v) \
-  do {                                                                 \
-    UTItype _r;                                                        \
-    _r = (UTItype) u * v;                                              \
-    (w1) = _r >> 64;                                                   \
-    (w0) = (UDItype) _r;                                               \
-  } while (0)
-#elif __GNUC__ > 2 || __GNUC_MINOR__ >= 7
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("dmultu %2,%3"                                               \
-	   : "=l" ((UDItype)(w0)),                                      \
-	     "=h" ((UDItype)(w1))                                       \
-	   : "d" ((UDItype)(u)),                                        \
-	     "d" ((UDItype)(v)))
-#else
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("dmultu %2,%3 \n"    \
-	   "mflo %0 \n"         \
-	   "mfhi %1"                                                        \
-	   : "=d" ((UDItype)(w0)),                                      \
-	     "=d" ((UDItype)(w1))                                       \
-	   : "d" ((UDItype)(u)),                                        \
-	     "d" ((UDItype)(v)))
-#endif
-#define UMUL_TIME 20
-#define UDIV_TIME 140
-#endif /* __mips__ */
-
-
-/***************************************
- **************  32000	****************
- ***************************************/
-#if defined (__ns32000__) && W_TYPE_SIZE == 32
-#define umul_ppmm(w1, w0, u, v) \
-  ({union {UDItype __ll;						\
-	   struct {USItype __l, __h;} __i;				\
-	  } __xx;							\
-  __asm__ ("meid %2,%0"                                                 \
-	   : "=g" (__xx.__ll)                                           \
-	   : "%0" ((USItype)(u)),                                       \
-	     "g" ((USItype)(v)));                                       \
-  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
-#define __umulsidi3(u, v) \
-  ({UDItype __w;							\
-    __asm__ ("meid %2,%0"                                               \
-	     : "=g" (__w)                                               \
-	     : "%0" ((USItype)(u)),                                     \
-	       "g" ((USItype)(v)));                                     \
-    __w; })
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  ({union {UDItype __ll;						\
-	   struct {USItype __l, __h;} __i;				\
-	  } __xx;							\
-  __xx.__i.__h = (n1); __xx.__i.__l = (n0);				\
-  __asm__ ("deid %2,%0"                                                 \
-	   : "=g" (__xx.__ll)                                           \
-	   : "0" (__xx.__ll),                                           \
-	     "g" ((USItype)(d)));                                       \
-  (r) = __xx.__i.__l; (q) = __xx.__i.__h; })
-#define count_trailing_zeros(count,x) \
-  do {
-    __asm__ ("ffsd      %2,%0"                                          \
-	     : "=r" ((USItype) (count))                                 \
-	     : "0" ((USItype) 0),                                       \
-	       "r" ((USItype) (x)));                                    \
-  } while (0)
-#endif /* __ns32000__ */
-
-
-/***************************************
- **************  PPC  ******************
- ***************************************/
-#if (defined (_ARCH_PPC) || defined (_IBMR2)) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  do {									\
-    if (__builtin_constant_p (bh) && (bh) == 0) 			\
-      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"           \
-	     : "=r" ((USItype)(sh)),                                    \
-	       "=&r" ((USItype)(sl))                                    \
-	     : "%r" ((USItype)(ah)),                                    \
-	       "%r" ((USItype)(al)),                                    \
-	       "rI" ((USItype)(bl)));                                   \
-    else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)		\
-      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"           \
-	     : "=r" ((USItype)(sh)),                                    \
-	       "=&r" ((USItype)(sl))                                    \
-	     : "%r" ((USItype)(ah)),                                    \
-	       "%r" ((USItype)(al)),                                    \
-	       "rI" ((USItype)(bl)));                                   \
-    else								\
-      __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"          \
-	     : "=r" ((USItype)(sh)),                                    \
-	       "=&r" ((USItype)(sl))                                    \
-	     : "%r" ((USItype)(ah)),                                    \
-	       "r" ((USItype)(bh)),                                     \
-	       "%r" ((USItype)(al)),                                    \
-	       "rI" ((USItype)(bl)));                                   \
-  } while (0)
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  do {									\
-    if (__builtin_constant_p (ah) && (ah) == 0) 			\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"       \
-	       : "=r" ((USItype)(sh)),                                  \
-		 "=&r" ((USItype)(sl))                                  \
-	       : "r" ((USItype)(bh)),                                   \
-		 "rI" ((USItype)(al)),                                  \
-		 "r" ((USItype)(bl)));                                  \
-    else if (__builtin_constant_p (ah) && (ah) ==~(USItype) 0)		\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"       \
-	       : "=r" ((USItype)(sh)),                                  \
-		 "=&r" ((USItype)(sl))                                  \
-	       : "r" ((USItype)(bh)),                                   \
-		 "rI" ((USItype)(al)),                                  \
-		 "r" ((USItype)(bl)));                                  \
-    else if (__builtin_constant_p (bh) && (bh) == 0)			\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"         \
-	       : "=r" ((USItype)(sh)),                                  \
-		 "=&r" ((USItype)(sl))                                  \
-	       : "r" ((USItype)(ah)),                                   \
-		 "rI" ((USItype)(al)),                                  \
-		 "r" ((USItype)(bl)));                                  \
-    else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)		\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"         \
-	       : "=r" ((USItype)(sh)),                                  \
-		 "=&r" ((USItype)(sl))                                  \
-	       : "r" ((USItype)(ah)),                                   \
-		 "rI" ((USItype)(al)),                                  \
-		 "r" ((USItype)(bl)));                                  \
-    else								\
-      __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"      \
-	       : "=r" ((USItype)(sh)),                                  \
-		 "=&r" ((USItype)(sl))                                  \
-	       : "r" ((USItype)(ah)),                                   \
-		 "r" ((USItype)(bh)),                                   \
-		 "rI" ((USItype)(al)),                                  \
-		 "r" ((USItype)(bl)));                                  \
-  } while (0)
-#define count_leading_zeros(count, x) \
-  __asm__ ("{cntlz|cntlzw} %0,%1"                                       \
-	   : "=r" ((USItype)(count))                                    \
-	   : "r" ((USItype)(x)))
-#define COUNT_LEADING_ZEROS_0 32
-#if defined (_ARCH_PPC)
-#define umul_ppmm(ph, pl, m0, m1) \
-  do {									\
-    USItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("mulhwu %0,%1,%2"                                          \
-	     : "=r" ((USItype) ph)                                      \
-	     : "%r" (__m0),                                             \
-	       "r" (__m1));                                             \
-    (pl) = __m0 * __m1; 						\
-  } while (0)
-#define UMUL_TIME 15
-#define smul_ppmm(ph, pl, m0, m1) \
-  do {									\
-    SItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("mulhw %0,%1,%2"                                           \
-	     : "=r" ((SItype) ph)                                       \
-	     : "%r" (__m0),                                             \
-	       "r" (__m1));                                             \
-    (pl) = __m0 * __m1; 						\
-  } while (0)
-#define SMUL_TIME 14
-#define UDIV_TIME 120
-#else
-#define umul_ppmm(xh, xl, m0, m1) \
-  do {									\
-    USItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("mul %0,%2,%3"                                             \
-	     : "=r" ((USItype)(xh)),                                    \
-	       "=q" ((USItype)(xl))                                     \
-	     : "r" (__m0),                                              \
-	       "r" (__m1));                                             \
-    (xh) += ((((SItype) __m0 >> 31) & __m1)				\
-	     + (((SItype) __m1 >> 31) & __m0)); 			\
-  } while (0)
-#define UMUL_TIME 8
-#define smul_ppmm(xh, xl, m0, m1) \
-  __asm__ ("mul %0,%2,%3"                                               \
-	   : "=r" ((SItype)(xh)),                                       \
-	     "=q" ((SItype)(xl))                                        \
-	   : "r" (m0),                                                  \
-	     "r" (m1))
-#define SMUL_TIME 4
-#define sdiv_qrnnd(q, r, nh, nl, d) \
-  __asm__ ("div %0,%2,%4"                                               \
-	   : "=r" ((SItype)(q)), "=q" ((SItype)(r))                     \
-	   : "r" ((SItype)(nh)), "1" ((SItype)(nl)), "r" ((SItype)(d)))
-#define UDIV_TIME 100
-#endif
-#endif /* Power architecture variants.	*/
-
-/* Powerpc 64 bit support taken from gmp-4.1.2. */
-/* We should test _IBMR2 here when we add assembly support for the system
-   vendor compilers.  */
-#if 0 /* Not yet enabled becuase we don't have hardware for a test. */
-#if (defined (_ARCH_PPC) || defined (__powerpc__)) && W_TYPE_SIZE == 64
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  do {									\
-    if (__builtin_constant_p (bh) && (bh) == 0)				\
-      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"		\
-	     : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
-    else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0)		\
-      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"		\
-	     : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\
-    else								\
-      __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"		\
-	     : "=r" (sh), "=&r" (sl)					\
-	     : "%r" (ah), "r" (bh), "%r" (al), "rI" (bl));		\
-  } while (0)
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  do {									\
-    if (__builtin_constant_p (ah) && (ah) == 0)				\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"	\
-	       : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
-    else if (__builtin_constant_p (ah) && (ah) == ~(UDItype) 0)		\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"	\
-	       : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\
-    else if (__builtin_constant_p (bh) && (bh) == 0)			\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"		\
-	       : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
-    else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0)		\
-      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"		\
-	       : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\
-    else								\
-      __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"	\
-	       : "=r" (sh), "=&r" (sl)					\
-	       : "r" (ah), "r" (bh), "rI" (al), "r" (bl));		\
-  } while (0)
-#define count_leading_zeros(count, x) \
-  __asm__ ("cntlzd %0,%1" : "=r" (count) : "r" (x))
-#define COUNT_LEADING_ZEROS_0 64
-#define umul_ppmm(ph, pl, m0, m1) \
-  do {									\
-    UDItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("mulhdu %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));	\
-    (pl) = __m0 * __m1;							\
-  } while (0)
-#define UMUL_TIME 15
-#define smul_ppmm(ph, pl, m0, m1) \
-  do {									\
-    DItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("mulhd %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));	\
-    (pl) = __m0 * __m1;							\
-  } while (0)
-#define SMUL_TIME 14  /* ??? */
-#define UDIV_TIME 120 /* ??? */
-#endif /* 64-bit PowerPC.  */
-#endif /* if 0 */
-
-/***************************************
- **************  PYR  ******************
- ***************************************/
-#if defined (__pyr__) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("addw        %5,%1 \n" \
-	   "addwc	%3,%0"                                          \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%0" ((USItype)(ah)),                                      \
-	     "g" ((USItype)(bh)),                                       \
-	     "%1" ((USItype)(al)),                                      \
-	     "g" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("subw        %5,%1 \n" \
-	   "subwb	%3,%0"                                          \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "0" ((USItype)(ah)),                                       \
-	     "g" ((USItype)(bh)),                                       \
-	     "1" ((USItype)(al)),                                       \
-	     "g" ((USItype)(bl)))
-/* This insn works on Pyramids with AP, XP, or MI CPUs, but not with SP.  */
-#define umul_ppmm(w1, w0, u, v) \
-  ({union {UDItype __ll;						\
-	   struct {USItype __h, __l;} __i;				\
-	  } __xx;							\
-  __asm__ ("movw %1,%R0 \n" \
-	   "uemul %2,%0"                                                \
-	   : "=&r" (__xx.__ll)                                          \
-	   : "g" ((USItype) (u)),                                       \
-	     "g" ((USItype)(v)));                                       \
-  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})
-#endif /* __pyr__ */
-
-
-/***************************************
- **************  RT/ROMP  **************
- ***************************************/
-#if defined (__ibm032__) /* RT/ROMP */	&& W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("a %1,%5 \n" \
-	   "ae %0,%3"                                                   \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%0" ((USItype)(ah)),                                      \
-	     "r" ((USItype)(bh)),                                       \
-	     "%1" ((USItype)(al)),                                      \
-	     "r" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("s %1,%5\n" \
-	   "se %0,%3"                                                   \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "0" ((USItype)(ah)),                                       \
-	     "r" ((USItype)(bh)),                                       \
-	     "1" ((USItype)(al)),                                       \
-	     "r" ((USItype)(bl)))
-#define umul_ppmm(ph, pl, m0, m1) \
-  do {									\
-    USItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ (								\
-       "s       r2,r2    \n" \
-       "mts	r10,%2   \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "m	r2,%3    \n" \
-       "cas	%0,r2,r0 \n" \
-       "mfs	r10,%1"                                                 \
-	     : "=r" ((USItype)(ph)),                                    \
-	       "=r" ((USItype)(pl))                                     \
-	     : "%r" (__m0),                                             \
-		"r" (__m1)                                              \
-	     : "r2");                                                   \
-    (ph) += ((((SItype) __m0 >> 31) & __m1)				\
-	     + (((SItype) __m1 >> 31) & __m0)); 			\
-  } while (0)
-#define UMUL_TIME 20
-#define UDIV_TIME 200
-#define count_leading_zeros(count, x) \
-  do {									\
-    if ((x) >= 0x10000) 						\
-      __asm__ ("clz     %0,%1"                                          \
-	       : "=r" ((USItype)(count))                                \
-	       : "r" ((USItype)(x) >> 16));                             \
-    else								\
-      { 								\
-	__asm__ ("clz   %0,%1"                                          \
-		 : "=r" ((USItype)(count))                              \
-		 : "r" ((USItype)(x)));                                 \
-	(count) += 16;							\
-      } 								\
-  } while (0)
-#endif /* RT/ROMP */
-
-
-/***************************************
- **************  SH2  ******************
- ***************************************/
-#if (defined (__sh2__) || defined(__sh3__) || defined(__SH4__) ) \
-    && W_TYPE_SIZE == 32
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ (								\
-        "dmulu.l %2,%3\n"  \
-	"sts	macl,%1\n" \
-	"sts	mach,%0"                                                \
-	   : "=r" ((USItype)(w1)),                                      \
-	     "=r" ((USItype)(w0))                                       \
-	   : "r" ((USItype)(u)),                                        \
-	     "r" ((USItype)(v))                                         \
-	   : "macl", "mach")
-#define UMUL_TIME 5
-#endif
-
-/***************************************
- **************  SPARC	****************
- ***************************************/
-#if defined (__sparc__) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("addcc %r4,%5,%1\n" \
-	   "addx %r2,%3,%0"                                             \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "%rJ" ((USItype)(ah)),                                     \
-	     "rI" ((USItype)(bh)),                                      \
-	     "%rJ" ((USItype)(al)),                                     \
-	     "rI" ((USItype)(bl))                                       \
-	   __CLOBBER_CC)
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("subcc %r4,%5,%1\n" \
-	   "subx %r2,%3,%0"                                             \
-	   : "=r" ((USItype)(sh)),                                      \
-	     "=&r" ((USItype)(sl))                                      \
-	   : "rJ" ((USItype)(ah)),                                      \
-	     "rI" ((USItype)(bh)),                                      \
-	     "rJ" ((USItype)(al)),                                      \
-	     "rI" ((USItype)(bl))                                       \
-	   __CLOBBER_CC)
-#if defined (__sparc_v8__)
-/* Don't match immediate range because, 1) it is not often useful,
-   2) the 'I' flag thinks of the range as a 13 bit signed interval,
-   while we want to match a 13 bit interval, sign extended to 32 bits,
-   but INTERPRETED AS UNSIGNED.  */
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("umul %2,%3,%1;rd %%y,%0"                                    \
-	   : "=r" ((USItype)(w1)),                                      \
-	     "=r" ((USItype)(w0))                                       \
-	   : "r" ((USItype)(u)),                                        \
-	     "r" ((USItype)(v)))
-#define UMUL_TIME 5
-#ifndef SUPERSPARC	/* SuperSPARC's udiv only handles 53 bit dividends */
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  do {									\
-    USItype __q;							\
-    __asm__ ("mov %1,%%y;nop;nop;nop;udiv %2,%3,%0"                     \
-	     : "=r" ((USItype)(__q))                                    \
-	     : "r" ((USItype)(n1)),                                     \
-	       "r" ((USItype)(n0)),                                     \
-	       "r" ((USItype)(d)));                                     \
-    (r) = (n0) - __q * (d);						\
-    (q) = __q;								\
-  } while (0)
-#define UDIV_TIME 25
-#endif /* SUPERSPARC */
-#else /* ! __sparc_v8__ */
-#if defined (__sparclite__)
-/* This has hardware multiply but not divide.  It also has two additional
-   instructions scan (ffs from high bit) and divscc.  */
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("umul %2,%3,%1;rd %%y,%0"                                    \
-	   : "=r" ((USItype)(w1)),                                      \
-	     "=r" ((USItype)(w0))                                       \
-	   : "r" ((USItype)(u)),                                        \
-	     "r" ((USItype)(v)))
-#define UMUL_TIME 5
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  __asm__ ("! Inlined udiv_qrnnd                                     \n" \
- "        wr	%%g0,%2,%%y	! Not a delayed write for sparclite  \n" \
- "        tst	%%g0                                                 \n" \
- "        divscc	%3,%4,%%g1                                   \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%%g1                                 \n" \
- "        divscc	%%g1,%4,%0                                   \n" \
- "        rd	%%y,%1                                               \n" \
- "        bl,a 1f                                                    \n" \
- "        add	%1,%4,%1                                             \n" \
- "1:	! End of inline udiv_qrnnd"                                     \
-	   : "=r" ((USItype)(q)),                                       \
-	     "=r" ((USItype)(r))                                        \
-	   : "r" ((USItype)(n1)),                                       \
-	     "r" ((USItype)(n0)),                                       \
-	     "rI" ((USItype)(d))                                        \
-	   : "%g1" __AND_CLOBBER_CC)
-#define UDIV_TIME 37
-#define count_leading_zeros(count, x) \
-  __asm__ ("scan %1,0,%0"                                               \
-	   : "=r" ((USItype)(x))                                        \
-	   : "r" ((USItype)(count)))
-/* Early sparclites return 63 for an argument of 0, but they warn that future
-   implementations might change this.  Therefore, leave COUNT_LEADING_ZEROS_0
-   undefined.  */
-#endif /* __sparclite__ */
-#endif /* __sparc_v8__ */
-/* Default to sparc v7 versions of umul_ppmm and udiv_qrnnd.  */
-#ifndef umul_ppmm
-#define umul_ppmm(w1, w0, u, v) \
-  __asm__ ("! Inlined umul_ppmm                                        \n" \
- "        wr	%%g0,%2,%%y	! SPARC has 0-3 delay insn after a wr  \n" \
- "        sra	%3,31,%%g2	! Don't move this insn                 \n" \
- "        and	%2,%%g2,%%g2	! Don't move this insn                 \n" \
- "        andcc	%%g0,0,%%g1	! Don't move this insn                 \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,%3,%%g1                                   \n" \
- "        mulscc	%%g1,0,%%g1                                    \n" \
- "        add	%%g1,%%g2,%0                                           \n" \
- "        rd	%%y,%1"                                                 \
-	   : "=r" ((USItype)(w1)),                                      \
-	     "=r" ((USItype)(w0))                                       \
-	   : "%rI" ((USItype)(u)),                                      \
-	     "r" ((USItype)(v))                                         \
-	   : "%g1", "%g2" __AND_CLOBBER_CC)
-#define UMUL_TIME 39		/* 39 instructions */
-#endif
-#ifndef udiv_qrnnd
-#ifndef LONGLONG_STANDALONE
-#define udiv_qrnnd(q, r, n1, n0, d) \
-  do { USItype __r;							\
-    (q) = __udiv_qrnnd (&__r, (n1), (n0), (d)); 			\
-    (r) = __r;								\
-  } while (0)
-extern USItype __udiv_qrnnd ();
-#define UDIV_TIME 140
-#endif /* LONGLONG_STANDALONE */
-#endif /* udiv_qrnnd */
-#endif /* __sparc__ */
-
-
-/***************************************
- **************  VAX  ******************
- ***************************************/
-#if defined (__vax__) && W_TYPE_SIZE == 32
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("addl2 %5,%1\n" \
-	   "adwc %3,%0"                                                 \
-	   : "=g" ((USItype)(sh)),                                      \
-	     "=&g" ((USItype)(sl))                                      \
-	   : "%0" ((USItype)(ah)),                                      \
-	     "g" ((USItype)(bh)),                                       \
-	     "%1" ((USItype)(al)),                                      \
-	     "g" ((USItype)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("subl2 %5,%1\n" \
-	   "sbwc %3,%0"                                                 \
-	   : "=g" ((USItype)(sh)),                                      \
-	     "=&g" ((USItype)(sl))                                      \
-	   : "0" ((USItype)(ah)),                                       \
-	     "g" ((USItype)(bh)),                                       \
-	     "1" ((USItype)(al)),                                       \
-	     "g" ((USItype)(bl)))
-#define umul_ppmm(xh, xl, m0, m1) \
-  do {									\
-    union {UDItype __ll;						\
-	   struct {USItype __l, __h;} __i;				\
-	  } __xx;							\
-    USItype __m0 = (m0), __m1 = (m1);					\
-    __asm__ ("emul %1,%2,$0,%0"                                         \
-	     : "=g" (__xx.__ll)                                         \
-	     : "g" (__m0),                                              \
-	       "g" (__m1));                                             \
-    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\
-    (xh) += ((((SItype) __m0 >> 31) & __m1)				\
-	     + (((SItype) __m1 >> 31) & __m0)); 			\
-  } while (0)
-#define sdiv_qrnnd(q, r, n1, n0, d) \
-  do {									\
-    union {DItype __ll; 						\
-	   struct {SItype __l, __h;} __i;				\
-	  } __xx;							\
-    __xx.__i.__h = n1; __xx.__i.__l = n0;				\
-    __asm__ ("ediv %3,%2,%0,%1"                                         \
-	     : "=g" (q), "=g" (r)                                       \
-	     : "g" (__xx.__ll), "g" (d));                               \
-  } while (0)
-#endif /* __vax__ */
-
-
-/***************************************
- **************  Z8000	****************
- ***************************************/
-#if defined (__z8000__) && W_TYPE_SIZE == 16
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  __asm__ ("add %H1,%H5\n\tadc  %H0,%H3"                                \
-	   : "=r" ((unsigned int)(sh)),                                 \
-	     "=&r" ((unsigned int)(sl))                                 \
-	   : "%0" ((unsigned int)(ah)),                                 \
-	     "r" ((unsigned int)(bh)),                                  \
-	     "%1" ((unsigned int)(al)),                                 \
-	     "rQR" ((unsigned int)(bl)))
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  __asm__ ("sub %H1,%H5\n\tsbc  %H0,%H3"                                \
-	   : "=r" ((unsigned int)(sh)),                                 \
-	     "=&r" ((unsigned int)(sl))                                 \
-	   : "0" ((unsigned int)(ah)),                                  \
-	     "r" ((unsigned int)(bh)),                                  \
-	     "1" ((unsigned int)(al)),                                  \
-	     "rQR" ((unsigned int)(bl)))
-#define umul_ppmm(xh, xl, m0, m1) \
-  do {									\
-    union {long int __ll;						\
-	   struct {unsigned int __h, __l;} __i; 			\
-	  } __xx;							\
-    unsigned int __m0 = (m0), __m1 = (m1);				\
-    __asm__ ("mult      %S0,%H3"                                        \
-	     : "=r" (__xx.__i.__h),                                     \
-	       "=r" (__xx.__i.__l)                                      \
-	     : "%1" (__m0),                                             \
-	       "rQR" (__m1));                                           \
-    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\
-    (xh) += ((((signed int) __m0 >> 15) & __m1) 			\
-	     + (((signed int) __m1 >> 15) & __m0));			\
-  } while (0)
-#endif /* __z8000__ */
-
-#endif /* __GNUC__ */
-#endif /* !__riscos__ */
-
-
-/***************************************
- ***********  Generic Versions	********
- ***************************************/
-#if !defined (umul_ppmm) && defined (__umulsidi3)
-#define umul_ppmm(ph, pl, m0, m1) \
-  {									\
-    UDWtype __ll = __umulsidi3 (m0, m1);				\
-    ph = (UWtype) (__ll >> W_TYPE_SIZE);				\
-    pl = (UWtype) __ll; 						\
-  }
-#endif
-
-#if !defined (__umulsidi3)
-#define __umulsidi3(u, v) \
-  ({UWtype __hi, __lo;							\
-    umul_ppmm (__hi, __lo, u, v);					\
-    ((UDWtype) __hi << W_TYPE_SIZE) | __lo; })
-#endif
-
-/* If this machine has no inline assembler, use C macros.  */
-
-#if !defined (add_ssaaaa)
-#define add_ssaaaa(sh, sl, ah, al, bh, bl) \
-  do {									\
-    UWtype __x; 							\
-    __x = (al) + (bl);							\
-    (sh) = (ah) + (bh) + (__x < (al));					\
-    (sl) = __x; 							\
-  } while (0)
-#endif
-
-#if !defined (sub_ddmmss)
-#define sub_ddmmss(sh, sl, ah, al, bh, bl) \
-  do {									\
-    UWtype __x; 							\
-    __x = (al) - (bl);							\
-    (sh) = (ah) - (bh) - (__x > (al));					\
-    (sl) = __x; 							\
-  } while (0)
-#endif
-
-#if !defined (umul_ppmm)
-#define umul_ppmm(w1, w0, u, v) 					\
-  do {									\
-    UWtype __x0, __x1, __x2, __x3;					\
-    UHWtype __ul, __vl, __uh, __vh;					\
-    UWtype __u = (u), __v = (v);					\
-									\
-    __ul = __ll_lowpart (__u);						\
-    __uh = __ll_highpart (__u); 					\
-    __vl = __ll_lowpart (__v);						\
-    __vh = __ll_highpart (__v); 					\
-									\
-    __x0 = (UWtype) __ul * __vl;					\
-    __x1 = (UWtype) __ul * __vh;					\
-    __x2 = (UWtype) __uh * __vl;					\
-    __x3 = (UWtype) __uh * __vh;					\
-									\
-    __x1 += __ll_highpart (__x0);/* this can't give carry */            \
-    __x1 += __x2;		/* but this indeed can */		\
-    if (__x1 < __x2)		/* did we get it? */			\
-      __x3 += __ll_B;		/* yes, add it in the proper pos. */	\
-									\
-    (w1) = __x3 + __ll_highpart (__x1); 				\
-    (w0) = (__ll_lowpart (__x1) << W_TYPE_SIZE/2) + __ll_lowpart (__x0);\
-  } while (0)
-#endif
-
-#if !defined (umul_ppmm)
-#define smul_ppmm(w1, w0, u, v) 					\
-  do {									\
-    UWtype __w1;							\
-    UWtype __m0 = (u), __m1 = (v);					\
-    umul_ppmm (__w1, w0, __m0, __m1);					\
-    (w1) = __w1 - (-(__m0 >> (W_TYPE_SIZE - 1)) & __m1) 		\
-		- (-(__m1 >> (W_TYPE_SIZE - 1)) & __m0);		\
-  } while (0)
-#endif
-
-/* Define this unconditionally, so it can be used for debugging.  */
-#define __udiv_qrnnd_c(q, r, n1, n0, d) \
-  do {									\
-    UWtype __d1, __d0, __q1, __q0, __r1, __r0, __m;			\
-    __d1 = __ll_highpart (d);						\
-    __d0 = __ll_lowpart (d);						\
-									\
-    __r1 = (n1) % __d1; 						\
-    __q1 = (n1) / __d1; 						\
-    __m = (UWtype) __q1 * __d0; 					\
-    __r1 = __r1 * __ll_B | __ll_highpart (n0);				\
-    if (__r1 < __m)							\
-      { 								\
-	__q1--, __r1 += (d);						\
-	if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\
-	  if (__r1 < __m)						\
-	    __q1--, __r1 += (d);					\
-      } 								\
-    __r1 -= __m;							\
-									\
-    __r0 = __r1 % __d1; 						\
-    __q0 = __r1 / __d1; 						\
-    __m = (UWtype) __q0 * __d0; 					\
-    __r0 = __r0 * __ll_B | __ll_lowpart (n0);				\
-    if (__r0 < __m)							\
-      { 								\
-	__q0--, __r0 += (d);						\
-	if (__r0 >= (d))						\
-	  if (__r0 < __m)						\
-	    __q0--, __r0 += (d);					\
-      } 								\
-    __r0 -= __m;							\
-									\
-    (q) = (UWtype) __q1 * __ll_B | __q0;				\
-    (r) = __r0; 							\
-  } while (0)
-
-/* If the processor has no udiv_qrnnd but sdiv_qrnnd, go through
-   __udiv_w_sdiv (defined in libgcc or elsewhere).  */
-#if !defined (udiv_qrnnd) && defined (sdiv_qrnnd)
-#define udiv_qrnnd(q, r, nh, nl, d) \
-  do {									\
-    UWtype __r; 							\
-    (q) = __MPN(udiv_w_sdiv) (&__r, nh, nl, d); 			\
-    (r) = __r;								\
-  } while (0)
-#endif
-
-/* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c.  */
-#if !defined (udiv_qrnnd)
-#define UDIV_NEEDS_NORMALIZATION 1
-#define udiv_qrnnd __udiv_qrnnd_c
-#endif
-
-#if !defined (count_leading_zeros)
-extern
-#ifdef __STDC__
-const
-#endif
-unsigned char _gcry_clz_tab[];
-#define MPI_INTERNAL_NEED_CLZ_TAB 1
-#define count_leading_zeros(count, x) \
-  do {									\
-    UWtype __xr = (x);							\
-    UWtype __a; 							\
-									\
-    if (W_TYPE_SIZE <= 32)						\
-      { 								\
-	__a = __xr < ((UWtype) 1 << 2*__BITS4)				\
-	  ? (__xr < ((UWtype) 1 << __BITS4) ? 0 : __BITS4)		\
-	  : (__xr < ((UWtype) 1 << 3*__BITS4) ?  2*__BITS4 : 3*__BITS4);\
-      } 								\
-    else								\
-      { 								\
-	for (__a = W_TYPE_SIZE - 8; __a > 0; __a -= 8)			\
-	  if (((__xr >> __a) & 0xff) != 0)				\
-	    break;							\
-      } 								\
-									\
-    (count) = W_TYPE_SIZE - (_gcry_clz_tab[__xr >> __a] + __a);		\
-  } while (0)
-/* This version gives a well-defined value for zero. */
-#define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE
-#endif
-
-#if !defined (count_trailing_zeros)
-/* Define count_trailing_zeros using count_leading_zeros.  The latter might be
-   defined in asm, but if it is not, the C version above is good enough.  */
-#define count_trailing_zeros(count, x) \
-  do {									\
-    UWtype __ctz_x = (x);						\
-    UWtype __ctz_c;							\
-    count_leading_zeros (__ctz_c, __ctz_x & -__ctz_x);			\
-    (count) = W_TYPE_SIZE - 1 - __ctz_c;				\
-  } while (0)
-#endif
-
-#ifndef UDIV_NEEDS_NORMALIZATION
-#define UDIV_NEEDS_NORMALIZATION 0
-#endif
+/* longlong.h -- definitions for mixed size 32/64 bit arithmetic.

+   Note: I added some stuff for use with gnupg

+

+Copyright (C) 1991, 1992, 1993, 1994, 1996, 1998,

+              2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.

+

+This file is free software; you can redistribute it and/or modify

+it under the terms of the GNU Lesser General Public License as published by

+the Free Software Foundation; either version 2.1 of the License, or (at your

+option) any later version.

+

+This file is distributed in the hope that it will be useful, but

+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

+License for more details.

+

+You should have received a copy of the GNU Library General Public License

+along with this file; see the file COPYING.LIB.  If not, write to

+the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

+MA 02111-1307, USA. */

+

+/* You have to define the following before including this file:

+

+   UWtype -- An unsigned type, default type for operations (typically a "word")

+   UHWtype -- An unsigned type, at least half the size of UWtype.

+   UDWtype -- An unsigned type, at least twice as large a UWtype

+   W_TYPE_SIZE -- size in bits of UWtype

+

+   SItype, USItype -- Signed and unsigned 32 bit types.

+   DItype, UDItype -- Signed and unsigned 64 bit types.

+

+   On a 32 bit machine UWtype should typically be USItype;

+   on a 64 bit machine, UWtype should typically be UDItype.

+*/

+

+#define __BITS4 (W_TYPE_SIZE / 4)

+#define __ll_B ((UWtype) 1 << (W_TYPE_SIZE / 2))

+#define __ll_lowpart(t) ((UWtype) (t) & (__ll_B - 1))

+#define __ll_highpart(t) ((UWtype) (t) >> (W_TYPE_SIZE / 2))

+

+/* This is used to make sure no undesirable sharing between different libraries

+   that use this file takes place.  */

+#ifndef __MPN

+#define __MPN(x) __##x

+#endif

+

+/* Define auxiliary asm macros.

+

+   1) umul_ppmm(high_prod, low_prod, multipler, multiplicand) multiplies two

+   UWtype integers MULTIPLER and MULTIPLICAND, and generates a two UWtype

+   word product in HIGH_PROD and LOW_PROD.

+

+   2) __umulsidi3(a,b) multiplies two UWtype integers A and B, and returns a

+   UDWtype product.  This is just a variant of umul_ppmm.

+

+   3) udiv_qrnnd(quotient, remainder, high_numerator, low_numerator,

+   denominator) divides a UDWtype, composed by the UWtype integers

+   HIGH_NUMERATOR and LOW_NUMERATOR, by DENOMINATOR and places the quotient

+   in QUOTIENT and the remainder in REMAINDER.	HIGH_NUMERATOR must be less

+   than DENOMINATOR for correct operation.  If, in addition, the most

+   significant bit of DENOMINATOR must be 1, then the pre-processor symbol

+   UDIV_NEEDS_NORMALIZATION is defined to 1.

+

+   4) sdiv_qrnnd(quotient, remainder, high_numerator, low_numerator,

+   denominator).  Like udiv_qrnnd but the numbers are signed.  The quotient

+   is rounded towards 0.

+

+   5) count_leading_zeros(count, x) counts the number of zero-bits from the

+   msb to the first non-zero bit in the UWtype X.  This is the number of

+   steps X needs to be shifted left to set the msb.  Undefined for X == 0,

+   unless the symbol COUNT_LEADING_ZEROS_0 is defined to some value.

+

+   6) count_trailing_zeros(count, x) like count_leading_zeros, but counts

+   from the least significant end.

+

+   7) add_ssaaaa(high_sum, low_sum, high_addend_1, low_addend_1,

+   high_addend_2, low_addend_2) adds two UWtype integers, composed by

+   HIGH_ADDEND_1 and LOW_ADDEND_1, and HIGH_ADDEND_2 and LOW_ADDEND_2

+   respectively.  The result is placed in HIGH_SUM and LOW_SUM.  Overflow

+   (i.e. carry out) is not stored anywhere, and is lost.

+

+   8) sub_ddmmss(high_difference, low_difference, high_minuend, low_minuend,

+   high_subtrahend, low_subtrahend) subtracts two two-word UWtype integers,

+   composed by HIGH_MINUEND_1 and LOW_MINUEND_1, and HIGH_SUBTRAHEND_2 and

+   LOW_SUBTRAHEND_2 respectively.  The result is placed in HIGH_DIFFERENCE

+   and LOW_DIFFERENCE.	Overflow (i.e. carry out) is not stored anywhere,

+   and is lost.

+

+   If any of these macros are left undefined for a particular CPU,

+   C macros are used.  */

+

+/* The CPUs come in alphabetical order below.

+

+   Please add support for more CPUs here, or improve the current support

+   for the CPUs below!	*/

+

+#ifdef __riscos__

+#pragma continue_after_hash_error

+#else /* !__riscos__ */

+#if defined (__GNUC__) && !defined (NO_ASM)

+

+/* We sometimes need to clobber "cc" with gcc2, but that would not be

+   understood by gcc1.	Use cpp to avoid major code duplication.  */

+#if __GNUC__ < 2

+#define __CLOBBER_CC

+#define __AND_CLOBBER_CC

+#else /* __GNUC__ >= 2 */

+#define __CLOBBER_CC : "cc"

+#define __AND_CLOBBER_CC , "cc"

+#endif /* __GNUC__ < 2 */

+

+

+/***************************************

+ **************  A29K  *****************

+ ***************************************/

+#if (defined (__a29k__) || defined (_AM29K)) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("add %1,%4,%5\n"   \

+           "addc %0,%2,%3"                                              \

+	   : "=r" ((USItype)(sh)),                                      \

+	    "=&r" ((USItype)(sl))                                       \

+	   : "%r" ((USItype)(ah)),                                      \

+	     "rI" ((USItype)(bh)),                                      \

+	     "%r" ((USItype)(al)),                                      \

+	     "rI" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("sub %1,%4,%5\n"                                             \

+	   "subc %0,%2,%3"                                              \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "r" ((USItype)(ah)),                                       \

+	     "rI" ((USItype)(bh)),                                      \

+	     "r" ((USItype)(al)),                                       \

+	     "rI" ((USItype)(bl)))

+#define umul_ppmm(xh, xl, m0, m1) \

+  do {									\

+    USItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("multiplu %0,%1,%2"                                        \

+	     : "=r" ((USItype)(xl))                                     \

+	     : "r" (__m0),                                              \

+	       "r" (__m1));                                             \

+    __asm__ ("multmu %0,%1,%2"                                          \

+	     : "=r" ((USItype)(xh))                                     \

+	     : "r" (__m0),                                              \

+	       "r" (__m1));                                             \

+  } while (0)

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  __asm__ ("dividu %0,%3,%4"                                            \

+	   : "=r" ((USItype)(q)),                                       \

+	     "=q" ((USItype)(r))                                        \

+	   : "1" ((USItype)(n1)),                                       \

+	     "r" ((USItype)(n0)),                                       \

+	     "r" ((USItype)(d)))

+#define count_leading_zeros(count, x) \

+    __asm__ ("clz %0,%1"                                                \

+	     : "=r" ((USItype)(count))                                  \

+	     : "r" ((USItype)(x)))

+#define COUNT_LEADING_ZEROS_0 32

+#endif /* __a29k__ */

+

+

+#if defined (__alpha) && W_TYPE_SIZE == 64

+#define umul_ppmm(ph, pl, m0, m1) \

+  do {									\

+    UDItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("umulh %r1,%2,%0"                                          \

+	     : "=r" ((UDItype) ph)                                      \

+	     : "%rJ" (__m0),                                            \

+	       "rI" (__m1));                                            \

+    (pl) = __m0 * __m1; 						\

+  } while (0)

+#define UMUL_TIME 46

+#ifndef LONGLONG_STANDALONE

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  do { UDItype __r;							\

+    (q) = __udiv_qrnnd (&__r, (n1), (n0), (d)); 			\

+    (r) = __r;								\

+  } while (0)

+extern UDItype __udiv_qrnnd ();

+#define UDIV_TIME 220

+#endif /* LONGLONG_STANDALONE */

+#endif /* __alpha */

+

+/***************************************

+ **************  ARM  ******************

+ ***************************************/

+#if defined (__arm__) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("adds %1, %4, %5\n"                                          \

+	   "adc  %0, %2, %3"                                            \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%r" ((USItype)(ah)),                                      \

+	     "rI" ((USItype)(bh)),                                      \

+	     "%r" ((USItype)(al)),                                      \

+	     "rI" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("subs %1, %4, %5\n"                                          \

+	   "sbc  %0, %2, %3"                                            \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "r" ((USItype)(ah)),                                       \

+	     "rI" ((USItype)(bh)),                                      \

+	     "r" ((USItype)(al)),                                       \

+	     "rI" ((USItype)(bl)))

+#if defined __ARM_ARCH_2__ || defined __ARM_ARCH_3__

+#define umul_ppmm(xh, xl, a, b) \

+  __asm__ ("%@ Inlined umul_ppmm\n"                                     \

+	"mov	%|r0, %2, lsr #16		@ AAAA\n"               \

+	"mov	%|r2, %3, lsr #16		@ BBBB\n"               \

+	"bic	%|r1, %2, %|r0, lsl #16		@ aaaa\n"               \

+	"bic	%0, %3, %|r2, lsl #16		@ bbbb\n"               \

+	"mul	%1, %|r1, %|r2			@ aaaa * BBBB\n"        \

+	"mul	%|r2, %|r0, %|r2		@ AAAA * BBBB\n"        \

+	"mul	%|r1, %0, %|r1			@ aaaa * bbbb\n"        \

+	"mul	%0, %|r0, %0			@ AAAA * bbbb\n"        \

+	"adds	%|r0, %1, %0			@ central sum\n"        \

+	"addcs	%|r2, %|r2, #65536\n"                                   \

+	"adds	%1, %|r1, %|r0, lsl #16\n"                              \

+	"adc	%0, %|r2, %|r0, lsr #16"                                \

+	   : "=&r" ((USItype)(xh)),                                     \

+	     "=r" ((USItype)(xl))                                       \

+	   : "r" ((USItype)(a)),                                        \

+	     "r" ((USItype)(b))                                         \

+	   : "r0", "r1", "r2")

+#else

+#define umul_ppmm(xh, xl, a, b)                                         \

+  __asm__ ("%@ Inlined umul_ppmm\n"                                     \

+	   "umull %r1, %r0, %r2, %r3"                                   \

+		   : "=&r" ((USItype)(xh)),                             \

+		     "=r" ((USItype)(xl))                               \

+		   : "r" ((USItype)(a)),                                \

+		     "r" ((USItype)(b))                                 \

+		   : "r0", "r1")

+#endif

+#define UMUL_TIME 20

+#define UDIV_TIME 100

+#endif /* __arm__ */

+

+/***************************************

+ **************  CLIPPER  **************

+ ***************************************/

+#if defined (__clipper__) && W_TYPE_SIZE == 32

+#define umul_ppmm(w1, w0, u, v) \

+  ({union {UDItype __ll;						\

+	   struct {USItype __l, __h;} __i;				\

+	  } __xx;							\

+  __asm__ ("mulwux %2,%0"                                               \

+	   : "=r" (__xx.__ll)                                           \

+	   : "%0" ((USItype)(u)),                                       \

+	     "r" ((USItype)(v)));                                       \

+  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})

+#define smul_ppmm(w1, w0, u, v) \

+  ({union {DItype __ll; 						\

+	   struct {SItype __l, __h;} __i;				\

+	  } __xx;							\

+  __asm__ ("mulwx %2,%0"                                                \

+	   : "=r" (__xx.__ll)                                           \

+	   : "%0" ((SItype)(u)),                                        \

+	     "r" ((SItype)(v)));                                        \

+  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})

+#define __umulsidi3(u, v) \

+  ({UDItype __w;							\

+    __asm__ ("mulwux %2,%0"                                             \

+	     : "=r" (__w)                                               \

+	     : "%0" ((USItype)(u)),                                     \

+	       "r" ((USItype)(v)));                                     \

+    __w; })

+#endif /* __clipper__ */

+

+

+/***************************************

+ **************  GMICRO  ***************

+ ***************************************/

+#if defined (__gmicro__) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("add.w %5,%1\n"                                              \

+	   "addx %3,%0"                                                 \

+	   : "=g" ((USItype)(sh)),                                      \

+	     "=&g" ((USItype)(sl))                                      \

+	   : "%0" ((USItype)(ah)),                                      \

+	     "g" ((USItype)(bh)),                                       \

+	     "%1" ((USItype)(al)),                                      \

+	     "g" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("sub.w %5,%1\n"                                              \

+	   "subx %3,%0"                                                 \

+	   : "=g" ((USItype)(sh)),                                      \

+	     "=&g" ((USItype)(sl))                                      \

+	   : "0" ((USItype)(ah)),                                       \

+	     "g" ((USItype)(bh)),                                       \

+	     "1" ((USItype)(al)),                                       \

+	     "g" ((USItype)(bl)))

+#define umul_ppmm(ph, pl, m0, m1) \

+  __asm__ ("mulx %3,%0,%1"                                              \

+	   : "=g" ((USItype)(ph)),                                      \

+	     "=r" ((USItype)(pl))                                       \

+	   : "%0" ((USItype)(m0)),                                      \

+	     "g" ((USItype)(m1)))

+#define udiv_qrnnd(q, r, nh, nl, d) \

+  __asm__ ("divx %4,%0,%1"                                              \

+	   : "=g" ((USItype)(q)),                                       \

+	     "=r" ((USItype)(r))                                        \

+	   : "1" ((USItype)(nh)),                                       \

+	     "0" ((USItype)(nl)),                                       \

+	     "g" ((USItype)(d)))

+#define count_leading_zeros(count, x) \

+  __asm__ ("bsch/1 %1,%0"                                               \

+	   : "=g" (count)                                               \

+	   : "g" ((USItype)(x)),                                        \

+	     "0" ((USItype)0))

+#endif

+

+

+/***************************************

+ **************  HPPA  *****************

+ ***************************************/

+#if defined (__hppa) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("	add %4,%5,%1\n"                                             \

+ 	   "	addc %2,%3,%0"                                              \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%rM" ((USItype)(ah)),                                     \

+	     "rM" ((USItype)(bh)),                                      \

+	     "%rM" ((USItype)(al)),                                     \

+	     "rM" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("	sub %4,%5,%1\n"                                             \

+	   "	subb %2,%3,%0"                                              \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "rM" ((USItype)(ah)),                                      \

+	     "rM" ((USItype)(bh)),                                      \

+	     "rM" ((USItype)(al)),                                      \

+	     "rM" ((USItype)(bl)))

+#if defined (_PA_RISC1_1)

+#define umul_ppmm(wh, wl, u, v) \

+  do {									\

+    union {UDItype __ll;						\

+	   struct {USItype __h, __l;} __i;				\

+	  } __xx;							\

+    __asm__ ("	xmpyu %1,%2,%0"                                           \

+	     : "=*f" (__xx.__ll)                                        \

+	     : "*f" ((USItype)(u)),                                     \

+	       "*f" ((USItype)(v)));                                    \

+    (wh) = __xx.__i.__h;						\

+    (wl) = __xx.__i.__l;						\

+  } while (0)

+#define UMUL_TIME 8

+#define UDIV_TIME 60

+#else

+#define UMUL_TIME 40

+#define UDIV_TIME 80

+#endif

+#ifndef LONGLONG_STANDALONE

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  do { USItype __r;							\

+    (q) = __udiv_qrnnd (&__r, (n1), (n0), (d)); 			\

+    (r) = __r;								\

+  } while (0)

+extern USItype __udiv_qrnnd ();

+#endif /* LONGLONG_STANDALONE */

+#define count_leading_zeros(count, x) \

+  do {								       \

+    USItype __tmp;						       \

+    __asm__ (				                               \

+       "	ldi             1,%0                                       \n" \

+       "	extru,= 	%1,15,16,%%r0  ; Bits 31..16 zero?         \n" \

+       "	extru,tr	%1,15,16,%1    ; No.  Shift down, skip add.\n" \

+       "	ldo		16(%0),%0      ; Yes.	Perform add.       \n" \

+       "	extru,= 	%1,23,8,%%r0   ; Bits 15..8 zero?          \n" \

+       "	extru,tr	%1,23,8,%1     ; No.  Shift down, skip add.\n" \

+       "	ldo		8(%0),%0       ; Yes.	Perform add.       \n" \

+       "	extru,= 	%1,27,4,%%r0   ; Bits 7..4 zero?           \n" \

+       "	extru,tr	%1,27,4,%1     ; No.  Shift down, skip add.\n" \

+       "	ldo		4(%0),%0       ; Yes.	Perform add.       \n" \

+       "	extru,= 	%1,29,2,%%r0   ; Bits 3..2 zero?           \n" \

+       "	extru,tr	%1,29,2,%1     ; No.  Shift down, skip add.\n" \

+       "	ldo		2(%0),%0       ; Yes.	Perform add.       \n" \

+       "	extru		%1,30,1,%1     ; Extract bit 1.            \n" \

+       "	sub		%0,%1,%0       ; Subtract it.              "   \

+       : "=r" (count), "=r" (__tmp) : "1" (x));                        \

+  } while (0)

+#endif /* hppa */

+

+

+/***************************************

+ **************  I370  *****************

+ ***************************************/

+#if (defined (__i370__) || defined (__mvs__)) && W_TYPE_SIZE == 32

+#define umul_ppmm(xh, xl, m0, m1) \

+  do {									\

+    union {UDItype __ll;						\

+	   struct {USItype __h, __l;} __i;				\

+	  } __xx;							\

+    USItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("mr %0,%3"                                                 \

+	     : "=r" (__xx.__i.__h),                                     \

+	       "=r" (__xx.__i.__l)                                      \

+	     : "%1" (__m0),                                             \

+	       "r" (__m1));                                             \

+    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\

+    (xh) += ((((SItype) __m0 >> 31) & __m1)				\

+	     + (((SItype) __m1 >> 31) & __m0)); 			\

+  } while (0)

+#define smul_ppmm(xh, xl, m0, m1) \

+  do {									\

+    union {DItype __ll; 						\

+	   struct {USItype __h, __l;} __i;				\

+	  } __xx;							\

+    __asm__ ("mr %0,%3"                                                 \

+	     : "=r" (__xx.__i.__h),                                     \

+	       "=r" (__xx.__i.__l)                                      \

+	     : "%1" (m0),                                               \

+	       "r" (m1));                                               \

+    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\

+  } while (0)

+#define sdiv_qrnnd(q, r, n1, n0, d) \

+  do {									\

+    union {DItype __ll; 						\

+	   struct {USItype __h, __l;} __i;				\

+	  } __xx;							\

+    __xx.__i.__h = n1; __xx.__i.__l = n0;				\

+    __asm__ ("dr %0,%2"                                                 \

+	     : "=r" (__xx.__ll)                                         \

+	     : "0" (__xx.__ll), "r" (d));                               \

+    (q) = __xx.__i.__l; (r) = __xx.__i.__h;				\

+  } while (0)

+#endif

+

+

+/***************************************

+ **************  I386  *****************

+ ***************************************/

+#if (defined (__i386__) || defined (__i486__)) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("addl %5,%1\n"                                               \

+	   "adcl %3,%0"                                                 \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%0" ((USItype)(ah)),                                      \

+	     "g" ((USItype)(bh)),                                       \

+	     "%1" ((USItype)(al)),                                      \

+	     "g" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("subl %5,%1\n"                                               \

+	   "sbbl %3,%0"                                                 \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "0" ((USItype)(ah)),                                       \

+	     "g" ((USItype)(bh)),                                       \

+	     "1" ((USItype)(al)),                                       \

+	     "g" ((USItype)(bl)))

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("mull %3"                                                    \

+	   : "=a" ((USItype)(w0)),                                      \

+	     "=d" ((USItype)(w1))                                       \

+	   : "%0" ((USItype)(u)),                                       \

+	     "rm" ((USItype)(v)))

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  __asm__ ("divl %4"                                                    \

+	   : "=a" ((USItype)(q)),                                       \

+	     "=d" ((USItype)(r))                                        \

+	   : "0" ((USItype)(n0)),                                       \

+	     "1" ((USItype)(n1)),                                       \

+	     "rm" ((USItype)(d)))

+#define count_leading_zeros(count, x) \

+  do {									\

+    USItype __cbtmp;							\

+    __asm__ ("bsrl %1,%0"                                               \

+	     : "=r" (__cbtmp) : "rm" ((USItype)(x)));                   \

+    (count) = __cbtmp ^ 31;						\

+  } while (0)

+#define count_trailing_zeros(count, x) \

+  __asm__ ("bsfl %1,%0" : "=r" (count) : "rm" ((USItype)(x)))

+#ifndef UMUL_TIME

+#define UMUL_TIME 40

+#endif

+#ifndef UDIV_TIME

+#define UDIV_TIME 40

+#endif

+#endif /* 80x86 */

+

+

+/***************************************

+ **************  I860  *****************

+ ***************************************/

+#if defined (__i860__) && W_TYPE_SIZE == 32

+#define rshift_rhlc(r,h,l,c) \

+  __asm__ ("shr %3,r0,r0\n"  \

+           "shrd %1,%2,%0"   \

+	   "=r" (r) : "r" (h), "r" (l), "rn" (c))

+#endif /* i860 */

+

+/***************************************

+ **************  I960  *****************

+ ***************************************/

+#if defined (__i960__) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("cmpo 1,0\n"      \

+           "addc %5,%4,%1\n" \

+           "addc %3,%2,%0"   \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%dI" ((USItype)(ah)),                                     \

+	     "dI" ((USItype)(bh)),                                      \

+	     "%dI" ((USItype)(al)),                                     \

+	     "dI" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("cmpo 0,0\n"      \

+           "subc %5,%4,%1\n" \

+           "subc %3,%2,%0"   \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "dI" ((USItype)(ah)),                                      \

+	     "dI" ((USItype)(bh)),                                      \

+	     "dI" ((USItype)(al)),                                      \

+	     "dI" ((USItype)(bl)))

+#define umul_ppmm(w1, w0, u, v) \

+  ({union {UDItype __ll;						\

+	   struct {USItype __l, __h;} __i;				\

+	  } __xx;							\

+  __asm__ ("emul        %2,%1,%0"                                       \

+	   : "=d" (__xx.__ll)                                           \

+	   : "%dI" ((USItype)(u)),                                      \

+	     "dI" ((USItype)(v)));                                      \

+  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})

+#define __umulsidi3(u, v) \

+  ({UDItype __w;							\

+    __asm__ ("emul      %2,%1,%0"                                       \

+	     : "=d" (__w)                                               \

+	     : "%dI" ((USItype)(u)),                                    \

+	       "dI" ((USItype)(v)));                                    \

+    __w; })

+#define udiv_qrnnd(q, r, nh, nl, d) \

+  do {									\

+    union {UDItype __ll;						\

+	   struct {USItype __l, __h;} __i;				\

+	  } __nn;							\

+    __nn.__i.__h = (nh); __nn.__i.__l = (nl);				\

+    __asm__ ("ediv %d,%n,%0"                                            \

+	   : "=d" (__rq.__ll)                                           \

+	   : "dI" (__nn.__ll),                                          \

+	     "dI" ((USItype)(d)));                                      \

+    (r) = __rq.__i.__l; (q) = __rq.__i.__h;				\

+  } while (0)

+#define count_leading_zeros(count, x) \

+  do {									\

+    USItype __cbtmp;							\

+    __asm__ ("scanbit %1,%0"                                            \

+	     : "=r" (__cbtmp)                                           \

+	     : "r" ((USItype)(x)));                                     \

+    (count) = __cbtmp ^ 31;						\

+  } while (0)

+#define COUNT_LEADING_ZEROS_0 (-32) /* sic */

+#if defined (__i960mx)		/* what is the proper symbol to test??? */

+#define rshift_rhlc(r,h,l,c) \

+  do {									\

+    union {UDItype __ll;						\

+	   struct {USItype __l, __h;} __i;				\

+	  } __nn;							\

+    __nn.__i.__h = (h); __nn.__i.__l = (l);				\

+    __asm__ ("shre %2,%1,%0"                                            \

+	     : "=d" (r) : "dI" (__nn.__ll), "dI" (c));                  \

+  }

+#endif /* i960mx */

+#endif /* i960 */

+

+

+/***************************************

+ **************  68000	****************

+ ***************************************/

+#if (defined (__mc68000__) || defined (__mc68020__) || defined (__NeXT__) || defined(mc68020)) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("add%.l %5,%1\n"                                             \

+	   "addx%.l %3,%0"                                              \

+	   : "=d" ((USItype)(sh)),                                      \

+	     "=&d" ((USItype)(sl))                                      \

+	   : "%0" ((USItype)(ah)),                                      \

+	     "d" ((USItype)(bh)),                                       \

+	     "%1" ((USItype)(al)),                                      \

+	     "g" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("sub%.l %5,%1\n"                                             \

+	   "subx%.l %3,%0"                                              \

+	   : "=d" ((USItype)(sh)),                                      \

+	     "=&d" ((USItype)(sl))                                      \

+	   : "0" ((USItype)(ah)),                                       \

+	     "d" ((USItype)(bh)),                                       \

+	     "1" ((USItype)(al)),                                       \

+	     "g" ((USItype)(bl)))

+#if (defined (__mc68020__) || defined (__NeXT__) || defined(mc68020))

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("mulu%.l %3,%1:%0"                                           \

+	   : "=d" ((USItype)(w0)),                                      \

+	     "=d" ((USItype)(w1))                                       \

+	   : "%0" ((USItype)(u)),                                       \

+	     "dmi" ((USItype)(v)))

+#define UMUL_TIME 45

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  __asm__ ("divu%.l %4,%1:%0"                                           \

+	   : "=d" ((USItype)(q)),                                       \

+	     "=d" ((USItype)(r))                                        \

+	   : "0" ((USItype)(n0)),                                       \

+	     "1" ((USItype)(n1)),                                       \

+	     "dmi" ((USItype)(d)))

+#define UDIV_TIME 90

+#define sdiv_qrnnd(q, r, n1, n0, d) \

+  __asm__ ("divs%.l %4,%1:%0"                                           \

+	   : "=d" ((USItype)(q)),                                       \

+	     "=d" ((USItype)(r))                                        \

+	   : "0" ((USItype)(n0)),                                       \

+	     "1" ((USItype)(n1)),                                       \

+	     "dmi" ((USItype)(d)))

+#define count_leading_zeros(count, x) \

+  __asm__ ("bfffo %1{%b2:%b2},%0"                                       \

+	   : "=d" ((USItype)(count))                                    \

+	   : "od" ((USItype)(x)), "n" (0))

+#define COUNT_LEADING_ZEROS_0 32

+#else /* not mc68020 */

+#define umul_ppmm(xh, xl, a, b) \

+  do { USItype __umul_tmp1, __umul_tmp2;			  \

+	__asm__ ("| Inlined umul_ppmm                         \n" \

+ "        move%.l %5,%3                                       \n" \

+ "        move%.l %2,%0                                       \n" \

+ "        move%.w %3,%1                                       \n" \

+ "        swap	%3                                            \n" \

+ "        swap	%0                                            \n" \

+ "        mulu	%2,%1                                         \n" \

+ "        mulu	%3,%0                                         \n" \

+ "        mulu	%2,%3                                         \n" \

+ "        swap	%2                                            \n" \

+ "        mulu	%5,%2                                         \n" \

+ "        add%.l	%3,%2                                 \n" \

+ "        jcc	1f                                            \n" \

+ "        add%.l	%#0x10000,%0                          \n" \

+ "1:	move%.l %2,%3                                         \n" \

+ "        clr%.w	%2                                    \n" \

+ "        swap	%2                                            \n" \

+ "        swap	%3                                            \n" \

+ "        clr%.w	%3                                    \n" \

+ "        add%.l	%3,%1                                 \n" \

+ "        addx%.l %2,%0                                       \n" \

+ "        | End inlined umul_ppmm"                                \

+	      : "=&d" ((USItype)(xh)), "=&d" ((USItype)(xl)),     \

+		"=d" (__umul_tmp1), "=&d" (__umul_tmp2)           \

+	      : "%2" ((USItype)(a)), "d" ((USItype)(b)));         \

+  } while (0)

+#define UMUL_TIME 100

+#define UDIV_TIME 400

+#endif /* not mc68020 */

+#endif /* mc68000 */

+

+

+/***************************************

+ **************  88000	****************

+ ***************************************/

+#if defined (__m88000__) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("addu.co %1,%r4,%r5\n"                                       \

+	   "addu.ci %0,%r2,%r3"                                         \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%rJ" ((USItype)(ah)),                                     \

+	     "rJ" ((USItype)(bh)),                                      \

+	     "%rJ" ((USItype)(al)),                                     \

+	     "rJ" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("subu.co %1,%r4,%r5\n"                                       \

+	   "subu.ci %0,%r2,%r3"                                         \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "rJ" ((USItype)(ah)),                                      \

+	     "rJ" ((USItype)(bh)),                                      \

+	     "rJ" ((USItype)(al)),                                      \

+	     "rJ" ((USItype)(bl)))

+#define count_leading_zeros(count, x) \

+  do {									\

+    USItype __cbtmp;							\

+    __asm__ ("ff1 %0,%1"                                                \

+	     : "=r" (__cbtmp)                                           \

+	     : "r" ((USItype)(x)));                                     \

+    (count) = __cbtmp ^ 31;						\

+  } while (0)

+#define COUNT_LEADING_ZEROS_0 63 /* sic */

+#if defined (__m88110__)

+#define umul_ppmm(wh, wl, u, v) \

+  do {									\

+    union {UDItype __ll;						\

+	   struct {USItype __h, __l;} __i;				\

+	  } __x;							\

+    __asm__ ("mulu.d %0,%1,%2" : "=r" (__x.__ll) : "r" (u), "r" (v));   \

+    (wh) = __x.__i.__h; 						\

+    (wl) = __x.__i.__l; 						\

+  } while (0)

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  ({union {UDItype __ll;						\

+	   struct {USItype __h, __l;} __i;				\

+	  } __x, __q;							\

+  __x.__i.__h = (n1); __x.__i.__l = (n0);				\

+  __asm__ ("divu.d %0,%1,%2"                                            \

+	   : "=r" (__q.__ll) : "r" (__x.__ll), "r" (d));                \

+  (r) = (n0) - __q.__l * (d); (q) = __q.__l; })

+#define UMUL_TIME 5

+#define UDIV_TIME 25

+#else

+#define UMUL_TIME 17

+#define UDIV_TIME 150

+#endif /* __m88110__ */

+#endif /* __m88000__ */

+

+/***************************************

+ **************  MIPS  *****************

+ ***************************************/

+#if defined (__mips__) && W_TYPE_SIZE == 32

+#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)

+#define umul_ppmm(w1, w0, u, v) \

+  do {                                                                  \

+    UDItype _r;                                                         \

+    _r = (UDItype) u * v;                                               \

+    (w1) = _r >> 32;                                                    \

+    (w0) = (USItype) _r;                                                \

+  } while (0)

+#elif __GNUC__ > 2 || __GNUC_MINOR__ >= 7

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("multu %2,%3"                                                \

+	   : "=l" ((USItype)(w0)),                                      \

+	     "=h" ((USItype)(w1))                                       \

+	   : "d" ((USItype)(u)),                                        \

+	     "d" ((USItype)(v)))

+#else

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("multu %2,%3 \n" \

+	   "mflo %0 \n"     \

+	   "mfhi %1"                                                        \

+	   : "=d" ((USItype)(w0)),                                      \

+	     "=d" ((USItype)(w1))                                       \

+	   : "d" ((USItype)(u)),                                        \

+	     "d" ((USItype)(v)))

+#endif

+#define UMUL_TIME 10

+#define UDIV_TIME 100

+#endif /* __mips__ */

+

+/***************************************

+ **************  MIPS/64  **************

+ ***************************************/

+#if (defined (__mips) && __mips >= 3) && W_TYPE_SIZE == 64

+#if (__GNUC__ >= 5) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)

+typedef unsigned int UTItype __attribute__ ((mode (TI)));

+#define umul_ppmm(w1, w0, u, v) \

+  do {                                                                 \

+    UTItype _r;                                                        \

+    _r = (UTItype) u * v;                                              \

+    (w1) = _r >> 64;                                                   \

+    (w0) = (UDItype) _r;                                               \

+  } while (0)

+#elif __GNUC__ > 2 || __GNUC_MINOR__ >= 7

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("dmultu %2,%3"                                               \

+	   : "=l" ((UDItype)(w0)),                                      \

+	     "=h" ((UDItype)(w1))                                       \

+	   : "d" ((UDItype)(u)),                                        \

+	     "d" ((UDItype)(v)))

+#else

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("dmultu %2,%3 \n"    \

+	   "mflo %0 \n"         \

+	   "mfhi %1"                                                        \

+	   : "=d" ((UDItype)(w0)),                                      \

+	     "=d" ((UDItype)(w1))                                       \

+	   : "d" ((UDItype)(u)),                                        \

+	     "d" ((UDItype)(v)))

+#endif

+#define UMUL_TIME 20

+#define UDIV_TIME 140

+#endif /* __mips__ */

+

+

+/***************************************

+ **************  32000	****************

+ ***************************************/

+#if defined (__ns32000__) && W_TYPE_SIZE == 32

+#define umul_ppmm(w1, w0, u, v) \

+  ({union {UDItype __ll;						\

+	   struct {USItype __l, __h;} __i;				\

+	  } __xx;							\

+  __asm__ ("meid %2,%0"                                                 \

+	   : "=g" (__xx.__ll)                                           \

+	   : "%0" ((USItype)(u)),                                       \

+	     "g" ((USItype)(v)));                                       \

+  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})

+#define __umulsidi3(u, v) \

+  ({UDItype __w;							\

+    __asm__ ("meid %2,%0"                                               \

+	     : "=g" (__w)                                               \

+	     : "%0" ((USItype)(u)),                                     \

+	       "g" ((USItype)(v)));                                     \

+    __w; })

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  ({union {UDItype __ll;						\

+	   struct {USItype __l, __h;} __i;				\

+	  } __xx;							\

+  __xx.__i.__h = (n1); __xx.__i.__l = (n0);				\

+  __asm__ ("deid %2,%0"                                                 \

+	   : "=g" (__xx.__ll)                                           \

+	   : "0" (__xx.__ll),                                           \

+	     "g" ((USItype)(d)));                                       \

+  (r) = __xx.__i.__l; (q) = __xx.__i.__h; })

+#define count_trailing_zeros(count,x) \

+  do {

+    __asm__ ("ffsd      %2,%0"                                          \

+	     : "=r" ((USItype) (count))                                 \

+	     : "0" ((USItype) 0),                                       \

+	       "r" ((USItype) (x)));                                    \

+  } while (0)

+#endif /* __ns32000__ */

+

+

+/***************************************

+ **************  PPC  ******************

+ ***************************************/

+#if (defined (_ARCH_PPC) || defined (_IBMR2)) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  do {									\

+    if (__builtin_constant_p (bh) && (bh) == 0) 			\

+      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"           \

+	     : "=r" ((USItype)(sh)),                                    \

+	       "=&r" ((USItype)(sl))                                    \

+	     : "%r" ((USItype)(ah)),                                    \

+	       "%r" ((USItype)(al)),                                    \

+	       "rI" ((USItype)(bl)));                                   \

+    else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)		\

+      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"           \

+	     : "=r" ((USItype)(sh)),                                    \

+	       "=&r" ((USItype)(sl))                                    \

+	     : "%r" ((USItype)(ah)),                                    \

+	       "%r" ((USItype)(al)),                                    \

+	       "rI" ((USItype)(bl)));                                   \

+    else								\

+      __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"          \

+	     : "=r" ((USItype)(sh)),                                    \

+	       "=&r" ((USItype)(sl))                                    \

+	     : "%r" ((USItype)(ah)),                                    \

+	       "r" ((USItype)(bh)),                                     \

+	       "%r" ((USItype)(al)),                                    \

+	       "rI" ((USItype)(bl)));                                   \

+  } while (0)

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  do {									\

+    if (__builtin_constant_p (ah) && (ah) == 0) 			\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"       \

+	       : "=r" ((USItype)(sh)),                                  \

+		 "=&r" ((USItype)(sl))                                  \

+	       : "r" ((USItype)(bh)),                                   \

+		 "rI" ((USItype)(al)),                                  \

+		 "r" ((USItype)(bl)));                                  \

+    else if (__builtin_constant_p (ah) && (ah) ==~(USItype) 0)		\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"       \

+	       : "=r" ((USItype)(sh)),                                  \

+		 "=&r" ((USItype)(sl))                                  \

+	       : "r" ((USItype)(bh)),                                   \

+		 "rI" ((USItype)(al)),                                  \

+		 "r" ((USItype)(bl)));                                  \

+    else if (__builtin_constant_p (bh) && (bh) == 0)			\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"         \

+	       : "=r" ((USItype)(sh)),                                  \

+		 "=&r" ((USItype)(sl))                                  \

+	       : "r" ((USItype)(ah)),                                   \

+		 "rI" ((USItype)(al)),                                  \

+		 "r" ((USItype)(bl)));                                  \

+    else if (__builtin_constant_p (bh) && (bh) ==~(USItype) 0)		\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"         \

+	       : "=r" ((USItype)(sh)),                                  \

+		 "=&r" ((USItype)(sl))                                  \

+	       : "r" ((USItype)(ah)),                                   \

+		 "rI" ((USItype)(al)),                                  \

+		 "r" ((USItype)(bl)));                                  \

+    else								\

+      __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"      \

+	       : "=r" ((USItype)(sh)),                                  \

+		 "=&r" ((USItype)(sl))                                  \

+	       : "r" ((USItype)(ah)),                                   \

+		 "r" ((USItype)(bh)),                                   \

+		 "rI" ((USItype)(al)),                                  \

+		 "r" ((USItype)(bl)));                                  \

+  } while (0)

+#define count_leading_zeros(count, x) \

+  __asm__ ("{cntlz|cntlzw} %0,%1"                                       \

+	   : "=r" ((USItype)(count))                                    \

+	   : "r" ((USItype)(x)))

+#define COUNT_LEADING_ZEROS_0 32

+#if defined (_ARCH_PPC)

+#define umul_ppmm(ph, pl, m0, m1) \

+  do {									\

+    USItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("mulhwu %0,%1,%2"                                          \

+	     : "=r" ((USItype) ph)                                      \

+	     : "%r" (__m0),                                             \

+	       "r" (__m1));                                             \

+    (pl) = __m0 * __m1; 						\

+  } while (0)

+#define UMUL_TIME 15

+#define smul_ppmm(ph, pl, m0, m1) \

+  do {									\

+    SItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("mulhw %0,%1,%2"                                           \

+	     : "=r" ((SItype) ph)                                       \

+	     : "%r" (__m0),                                             \

+	       "r" (__m1));                                             \

+    (pl) = __m0 * __m1; 						\

+  } while (0)

+#define SMUL_TIME 14

+#define UDIV_TIME 120

+#else

+#define umul_ppmm(xh, xl, m0, m1) \

+  do {									\

+    USItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("mul %0,%2,%3"                                             \

+	     : "=r" ((USItype)(xh)),                                    \

+	       "=q" ((USItype)(xl))                                     \

+	     : "r" (__m0),                                              \

+	       "r" (__m1));                                             \

+    (xh) += ((((SItype) __m0 >> 31) & __m1)				\

+	     + (((SItype) __m1 >> 31) & __m0)); 			\

+  } while (0)

+#define UMUL_TIME 8

+#define smul_ppmm(xh, xl, m0, m1) \

+  __asm__ ("mul %0,%2,%3"                                               \

+	   : "=r" ((SItype)(xh)),                                       \

+	     "=q" ((SItype)(xl))                                        \

+	   : "r" (m0),                                                  \

+	     "r" (m1))

+#define SMUL_TIME 4

+#define sdiv_qrnnd(q, r, nh, nl, d) \

+  __asm__ ("div %0,%2,%4"                                               \

+	   : "=r" ((SItype)(q)), "=q" ((SItype)(r))                     \

+	   : "r" ((SItype)(nh)), "1" ((SItype)(nl)), "r" ((SItype)(d)))

+#define UDIV_TIME 100

+#endif

+#endif /* Power architecture variants.	*/

+

+/* Powerpc 64 bit support taken from gmp-4.1.2. */

+/* We should test _IBMR2 here when we add assembly support for the system

+   vendor compilers.  */

+#if 0 /* Not yet enabled because we don't have hardware for a test. */

+#if (defined (_ARCH_PPC) || defined (__powerpc__)) && W_TYPE_SIZE == 64

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  do {									\

+    if (__builtin_constant_p (bh) && (bh) == 0)				\

+      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2"		\

+	     : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\

+    else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0)		\

+      __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"		\

+	     : "=r" (sh), "=&r" (sl) : "r" (ah), "%r" (al), "rI" (bl));\

+    else								\

+      __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3"		\

+	     : "=r" (sh), "=&r" (sl)					\

+	     : "%r" (ah), "r" (bh), "%r" (al), "rI" (bl));		\

+  } while (0)

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  do {									\

+    if (__builtin_constant_p (ah) && (ah) == 0)				\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfze|subfze} %0,%2"	\

+	       : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\

+    else if (__builtin_constant_p (ah) && (ah) == ~(UDItype) 0)		\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{sfme|subfme} %0,%2"	\

+	       : "=r" (sh), "=&r" (sl) : "r" (bh), "rI" (al), "r" (bl));\

+    else if (__builtin_constant_p (bh) && (bh) == 0)			\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{ame|addme} %0,%2"		\

+	       : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\

+    else if (__builtin_constant_p (bh) && (bh) == ~(UDItype) 0)		\

+      __asm__ ("{sf%I3|subf%I3c} %1,%4,%3\n\t{aze|addze} %0,%2"		\

+	       : "=r" (sh), "=&r" (sl) : "r" (ah), "rI" (al), "r" (bl));\

+    else								\

+      __asm__ ("{sf%I4|subf%I4c} %1,%5,%4\n\t{sfe|subfe} %0,%3,%2"	\

+	       : "=r" (sh), "=&r" (sl)					\

+	       : "r" (ah), "r" (bh), "rI" (al), "r" (bl));		\

+  } while (0)

+#define count_leading_zeros(count, x) \

+  __asm__ ("cntlzd %0,%1" : "=r" (count) : "r" (x))

+#define COUNT_LEADING_ZEROS_0 64

+#define umul_ppmm(ph, pl, m0, m1) \

+  do {									\

+    UDItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("mulhdu %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));	\

+    (pl) = __m0 * __m1;							\

+  } while (0)

+#define UMUL_TIME 15

+#define smul_ppmm(ph, pl, m0, m1) \

+  do {									\

+    DItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("mulhd %0,%1,%2" : "=r" (ph) : "%r" (m0), "r" (m1));	\

+    (pl) = __m0 * __m1;							\

+  } while (0)

+#define SMUL_TIME 14  /* ??? */

+#define UDIV_TIME 120 /* ??? */

+#endif /* 64-bit PowerPC.  */

+#endif /* if 0 */

+

+/***************************************

+ **************  PYR  ******************

+ ***************************************/

+#if defined (__pyr__) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("addw        %5,%1 \n" \

+	   "addwc	%3,%0"                                          \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%0" ((USItype)(ah)),                                      \

+	     "g" ((USItype)(bh)),                                       \

+	     "%1" ((USItype)(al)),                                      \

+	     "g" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("subw        %5,%1 \n" \

+	   "subwb	%3,%0"                                          \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "0" ((USItype)(ah)),                                       \

+	     "g" ((USItype)(bh)),                                       \

+	     "1" ((USItype)(al)),                                       \

+	     "g" ((USItype)(bl)))

+/* This insn works on Pyramids with AP, XP, or MI CPUs, but not with SP.  */

+#define umul_ppmm(w1, w0, u, v) \

+  ({union {UDItype __ll;						\

+	   struct {USItype __h, __l;} __i;				\

+	  } __xx;							\

+  __asm__ ("movw %1,%R0 \n" \

+	   "uemul %2,%0"                                                \

+	   : "=&r" (__xx.__ll)                                          \

+	   : "g" ((USItype) (u)),                                       \

+	     "g" ((USItype)(v)));                                       \

+  (w1) = __xx.__i.__h; (w0) = __xx.__i.__l;})

+#endif /* __pyr__ */

+

+

+/***************************************

+ **************  RT/ROMP  **************

+ ***************************************/

+#if defined (__ibm032__) /* RT/ROMP */	&& W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("a %1,%5 \n" \

+	   "ae %0,%3"                                                   \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%0" ((USItype)(ah)),                                      \

+	     "r" ((USItype)(bh)),                                       \

+	     "%1" ((USItype)(al)),                                      \

+	     "r" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("s %1,%5\n" \

+	   "se %0,%3"                                                   \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "0" ((USItype)(ah)),                                       \

+	     "r" ((USItype)(bh)),                                       \

+	     "1" ((USItype)(al)),                                       \

+	     "r" ((USItype)(bl)))

+#define umul_ppmm(ph, pl, m0, m1) \

+  do {									\

+    USItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ (								\

+       "s       r2,r2    \n" \

+       "mts	r10,%2   \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "m	r2,%3    \n" \

+       "cas	%0,r2,r0 \n" \

+       "mfs	r10,%1"                                                 \

+	     : "=r" ((USItype)(ph)),                                    \

+	       "=r" ((USItype)(pl))                                     \

+	     : "%r" (__m0),                                             \

+		"r" (__m1)                                              \

+	     : "r2");                                                   \

+    (ph) += ((((SItype) __m0 >> 31) & __m1)				\

+	     + (((SItype) __m1 >> 31) & __m0)); 			\

+  } while (0)

+#define UMUL_TIME 20

+#define UDIV_TIME 200

+#define count_leading_zeros(count, x) \

+  do {									\

+    if ((x) >= 0x10000) 						\

+      __asm__ ("clz     %0,%1"                                          \

+	       : "=r" ((USItype)(count))                                \

+	       : "r" ((USItype)(x) >> 16));                             \

+    else								\

+      { 								\

+	__asm__ ("clz   %0,%1"                                          \

+		 : "=r" ((USItype)(count))                              \

+		 : "r" ((USItype)(x)));                                 \

+	(count) += 16;							\

+      } 								\

+  } while (0)

+#endif /* RT/ROMP */

+

+

+/***************************************

+ **************  SH2  ******************

+ ***************************************/

+#if (defined (__sh2__) || defined(__sh3__) || defined(__SH4__) ) \

+    && W_TYPE_SIZE == 32

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ (								\

+        "dmulu.l %2,%3\n"  \

+	"sts	macl,%1\n" \

+	"sts	mach,%0"                                                \

+	   : "=r" ((USItype)(w1)),                                      \

+	     "=r" ((USItype)(w0))                                       \

+	   : "r" ((USItype)(u)),                                        \

+	     "r" ((USItype)(v))                                         \

+	   : "macl", "mach")

+#define UMUL_TIME 5

+#endif

+

+/***************************************

+ **************  SPARC	****************

+ ***************************************/

+#if defined (__sparc__) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("addcc %r4,%5,%1\n" \

+	   "addx %r2,%3,%0"                                             \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "%rJ" ((USItype)(ah)),                                     \

+	     "rI" ((USItype)(bh)),                                      \

+	     "%rJ" ((USItype)(al)),                                     \

+	     "rI" ((USItype)(bl))                                       \

+	   __CLOBBER_CC)

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("subcc %r4,%5,%1\n" \

+	   "subx %r2,%3,%0"                                             \

+	   : "=r" ((USItype)(sh)),                                      \

+	     "=&r" ((USItype)(sl))                                      \

+	   : "rJ" ((USItype)(ah)),                                      \

+	     "rI" ((USItype)(bh)),                                      \

+	     "rJ" ((USItype)(al)),                                      \

+	     "rI" ((USItype)(bl))                                       \

+	   __CLOBBER_CC)

+#if defined (__sparc_v8__)

+/* Don't match immediate range because, 1) it is not often useful,

+   2) the 'I' flag thinks of the range as a 13 bit signed interval,

+   while we want to match a 13 bit interval, sign extended to 32 bits,

+   but INTERPRETED AS UNSIGNED.  */

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("umul %2,%3,%1;rd %%y,%0"                                    \

+	   : "=r" ((USItype)(w1)),                                      \

+	     "=r" ((USItype)(w0))                                       \

+	   : "r" ((USItype)(u)),                                        \

+	     "r" ((USItype)(v)))

+#define UMUL_TIME 5

+#ifndef SUPERSPARC	/* SuperSPARC's udiv only handles 53 bit dividends */

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  do {									\

+    USItype __q;							\

+    __asm__ ("mov %1,%%y;nop;nop;nop;udiv %2,%3,%0"                     \

+	     : "=r" ((USItype)(__q))                                    \

+	     : "r" ((USItype)(n1)),                                     \

+	       "r" ((USItype)(n0)),                                     \

+	       "r" ((USItype)(d)));                                     \

+    (r) = (n0) - __q * (d);						\

+    (q) = __q;								\

+  } while (0)

+#define UDIV_TIME 25

+#endif /* SUPERSPARC */

+#else /* ! __sparc_v8__ */

+#if defined (__sparclite__)

+/* This has hardware multiply but not divide.  It also has two additional

+   instructions scan (ffs from high bit) and divscc.  */

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("umul %2,%3,%1;rd %%y,%0"                                    \

+	   : "=r" ((USItype)(w1)),                                      \

+	     "=r" ((USItype)(w0))                                       \

+	   : "r" ((USItype)(u)),                                        \

+	     "r" ((USItype)(v)))

+#define UMUL_TIME 5

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  __asm__ ("! Inlined udiv_qrnnd                                     \n" \

+ "        wr	%%g0,%2,%%y	! Not a delayed write for sparclite  \n" \

+ "        tst	%%g0                                                 \n" \

+ "        divscc	%3,%4,%%g1                                   \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%%g1                                 \n" \

+ "        divscc	%%g1,%4,%0                                   \n" \

+ "        rd	%%y,%1                                               \n" \

+ "        bl,a 1f                                                    \n" \

+ "        add	%1,%4,%1                                             \n" \

+ "1:	! End of inline udiv_qrnnd"                                     \

+	   : "=r" ((USItype)(q)),                                       \

+	     "=r" ((USItype)(r))                                        \

+	   : "r" ((USItype)(n1)),                                       \

+	     "r" ((USItype)(n0)),                                       \

+	     "rI" ((USItype)(d))                                        \

+	   : "%g1" __AND_CLOBBER_CC)

+#define UDIV_TIME 37

+#define count_leading_zeros(count, x) \

+  __asm__ ("scan %1,0,%0"                                               \

+	   : "=r" ((USItype)(x))                                        \

+	   : "r" ((USItype)(count)))

+/* Early sparclites return 63 for an argument of 0, but they warn that future

+   implementations might change this.  Therefore, leave COUNT_LEADING_ZEROS_0

+   undefined.  */

+#endif /* __sparclite__ */

+#endif /* __sparc_v8__ */

+/* Default to sparc v7 versions of umul_ppmm and udiv_qrnnd.  */

+#ifndef umul_ppmm

+#define umul_ppmm(w1, w0, u, v) \

+  __asm__ ("! Inlined umul_ppmm                                        \n" \

+ "        wr	%%g0,%2,%%y	! SPARC has 0-3 delay insn after a wr  \n" \

+ "        sra	%3,31,%%g2	! Don't move this insn                 \n" \

+ "        and	%2,%%g2,%%g2	! Don't move this insn                 \n" \

+ "        andcc	%%g0,0,%%g1	! Don't move this insn                 \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,%3,%%g1                                   \n" \

+ "        mulscc	%%g1,0,%%g1                                    \n" \

+ "        add	%%g1,%%g2,%0                                           \n" \

+ "        rd	%%y,%1"                                                 \

+	   : "=r" ((USItype)(w1)),                                      \

+	     "=r" ((USItype)(w0))                                       \

+	   : "%rI" ((USItype)(u)),                                      \

+	     "r" ((USItype)(v))                                         \

+	   : "%g1", "%g2" __AND_CLOBBER_CC)

+#define UMUL_TIME 39		/* 39 instructions */

+#endif

+#ifndef udiv_qrnnd

+#ifndef LONGLONG_STANDALONE

+#define udiv_qrnnd(q, r, n1, n0, d) \

+  do { USItype __r;							\

+    (q) = __udiv_qrnnd (&__r, (n1), (n0), (d)); 			\

+    (r) = __r;								\

+  } while (0)

+extern USItype __udiv_qrnnd ();

+#define UDIV_TIME 140

+#endif /* LONGLONG_STANDALONE */

+#endif /* udiv_qrnnd */

+#endif /* __sparc__ */

+

+

+/***************************************

+ **************  VAX  ******************

+ ***************************************/

+#if defined (__vax__) && W_TYPE_SIZE == 32

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("addl2 %5,%1\n" \

+	   "adwc %3,%0"                                                 \

+	   : "=g" ((USItype)(sh)),                                      \

+	     "=&g" ((USItype)(sl))                                      \

+	   : "%0" ((USItype)(ah)),                                      \

+	     "g" ((USItype)(bh)),                                       \

+	     "%1" ((USItype)(al)),                                      \

+	     "g" ((USItype)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("subl2 %5,%1\n" \

+	   "sbwc %3,%0"                                                 \

+	   : "=g" ((USItype)(sh)),                                      \

+	     "=&g" ((USItype)(sl))                                      \

+	   : "0" ((USItype)(ah)),                                       \

+	     "g" ((USItype)(bh)),                                       \

+	     "1" ((USItype)(al)),                                       \

+	     "g" ((USItype)(bl)))

+#define umul_ppmm(xh, xl, m0, m1) \

+  do {									\

+    union {UDItype __ll;						\

+	   struct {USItype __l, __h;} __i;				\

+	  } __xx;							\

+    USItype __m0 = (m0), __m1 = (m1);					\

+    __asm__ ("emul %1,%2,$0,%0"                                         \

+	     : "=g" (__xx.__ll)                                         \

+	     : "g" (__m0),                                              \

+	       "g" (__m1));                                             \

+    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\

+    (xh) += ((((SItype) __m0 >> 31) & __m1)				\

+	     + (((SItype) __m1 >> 31) & __m0)); 			\

+  } while (0)

+#define sdiv_qrnnd(q, r, n1, n0, d) \

+  do {									\

+    union {DItype __ll; 						\

+	   struct {SItype __l, __h;} __i;				\

+	  } __xx;							\

+    __xx.__i.__h = n1; __xx.__i.__l = n0;				\

+    __asm__ ("ediv %3,%2,%0,%1"                                         \

+	     : "=g" (q), "=g" (r)                                       \

+	     : "g" (__xx.__ll), "g" (d));                               \

+  } while (0)

+#endif /* __vax__ */

+

+

+/***************************************

+ **************  Z8000	****************

+ ***************************************/

+#if defined (__z8000__) && W_TYPE_SIZE == 16

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  __asm__ ("add %H1,%H5\n\tadc  %H0,%H3"                                \

+	   : "=r" ((unsigned int)(sh)),                                 \

+	     "=&r" ((unsigned int)(sl))                                 \

+	   : "%0" ((unsigned int)(ah)),                                 \

+	     "r" ((unsigned int)(bh)),                                  \

+	     "%1" ((unsigned int)(al)),                                 \

+	     "rQR" ((unsigned int)(bl)))

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  __asm__ ("sub %H1,%H5\n\tsbc  %H0,%H3"                                \

+	   : "=r" ((unsigned int)(sh)),                                 \

+	     "=&r" ((unsigned int)(sl))                                 \

+	   : "0" ((unsigned int)(ah)),                                  \

+	     "r" ((unsigned int)(bh)),                                  \

+	     "1" ((unsigned int)(al)),                                  \

+	     "rQR" ((unsigned int)(bl)))

+#define umul_ppmm(xh, xl, m0, m1) \

+  do {									\

+    union {long int __ll;						\

+	   struct {unsigned int __h, __l;} __i; 			\

+	  } __xx;							\

+    unsigned int __m0 = (m0), __m1 = (m1);				\

+    __asm__ ("mult      %S0,%H3"                                        \

+	     : "=r" (__xx.__i.__h),                                     \

+	       "=r" (__xx.__i.__l)                                      \

+	     : "%1" (__m0),                                             \

+	       "rQR" (__m1));                                           \

+    (xh) = __xx.__i.__h; (xl) = __xx.__i.__l;				\

+    (xh) += ((((signed int) __m0 >> 15) & __m1) 			\

+	     + (((signed int) __m1 >> 15) & __m0));			\

+  } while (0)

+#endif /* __z8000__ */

+

+#endif /* __GNUC__ */

+#endif /* !__riscos__ */

+

+

+/***************************************

+ ***********  Generic Versions	********

+ ***************************************/

+#if !defined (umul_ppmm) && defined (__umulsidi3)

+#define umul_ppmm(ph, pl, m0, m1) \

+  {									\

+    UDWtype __ll = __umulsidi3 (m0, m1);				\

+    ph = (UWtype) (__ll >> W_TYPE_SIZE);				\

+    pl = (UWtype) __ll; 						\

+  }

+#endif

+

+#if !defined (__umulsidi3)

+#define __umulsidi3(u, v) \

+  ({UWtype __hi, __lo;							\

+    umul_ppmm (__hi, __lo, u, v);					\

+    ((UDWtype) __hi << W_TYPE_SIZE) | __lo; })

+#endif

+

+/* If this machine has no inline assembler, use C macros.  */

+

+#if !defined (add_ssaaaa)

+#define add_ssaaaa(sh, sl, ah, al, bh, bl) \

+  do {									\

+    UWtype __x; 							\

+    __x = (al) + (bl);							\

+    (sh) = (ah) + (bh) + (__x < (al));					\

+    (sl) = __x; 							\

+  } while (0)

+#endif

+

+#if !defined (sub_ddmmss)

+#define sub_ddmmss(sh, sl, ah, al, bh, bl) \

+  do {									\

+    UWtype __x; 							\

+    __x = (al) - (bl);							\

+    (sh) = (ah) - (bh) - (__x > (al));					\

+    (sl) = __x; 							\

+  } while (0)

+#endif

+

+#if !defined (umul_ppmm)

+#define umul_ppmm(w1, w0, u, v) 					\

+  do {									\

+    UWtype __x0, __x1, __x2, __x3;					\

+    UHWtype __ul, __vl, __uh, __vh;					\

+    UWtype __u = (u), __v = (v);					\

+									\

+    __ul = __ll_lowpart (__u);						\

+    __uh = __ll_highpart (__u); 					\

+    __vl = __ll_lowpart (__v);						\

+    __vh = __ll_highpart (__v); 					\

+									\

+    __x0 = (UWtype) __ul * __vl;					\

+    __x1 = (UWtype) __ul * __vh;					\

+    __x2 = (UWtype) __uh * __vl;					\

+    __x3 = (UWtype) __uh * __vh;					\

+									\

+    __x1 += __ll_highpart (__x0);/* this can't give carry */            \

+    __x1 += __x2;		/* but this indeed can */		\

+    if (__x1 < __x2)		/* did we get it? */			\

+      __x3 += __ll_B;		/* yes, add it in the proper pos. */	\

+									\

+    (w1) = __x3 + __ll_highpart (__x1); 				\

+    (w0) = (__ll_lowpart (__x1) << W_TYPE_SIZE/2) + __ll_lowpart (__x0);\

+  } while (0)

+#endif

+

+#if !defined (umul_ppmm)

+#define smul_ppmm(w1, w0, u, v) 					\

+  do {									\

+    UWtype __w1;							\

+    UWtype __m0 = (u), __m1 = (v);					\

+    umul_ppmm (__w1, w0, __m0, __m1);					\

+    (w1) = __w1 - (-(__m0 >> (W_TYPE_SIZE - 1)) & __m1) 		\

+		- (-(__m1 >> (W_TYPE_SIZE - 1)) & __m0);		\

+  } while (0)

+#endif

+

+/* Define this unconditionally, so it can be used for debugging.  */

+#define __udiv_qrnnd_c(q, r, n1, n0, d) \

+  do {									\

+    UWtype __d1, __d0, __q1, __q0, __r1, __r0, __m;			\

+    __d1 = __ll_highpart (d);						\

+    __d0 = __ll_lowpart (d);						\

+									\

+    __r1 = (n1) % __d1; 						\

+    __q1 = (n1) / __d1; 						\

+    __m = (UWtype) __q1 * __d0; 					\

+    __r1 = __r1 * __ll_B | __ll_highpart (n0);				\

+    if (__r1 < __m)							\

+      { 								\

+	__q1--, __r1 += (d);						\

+	if (__r1 >= (d)) /* i.e. we didn't get carry when adding to __r1 */\

+	  if (__r1 < __m)						\

+	    __q1--, __r1 += (d);					\

+      } 								\

+    __r1 -= __m;							\

+									\

+    __r0 = __r1 % __d1; 						\

+    __q0 = __r1 / __d1; 						\

+    __m = (UWtype) __q0 * __d0; 					\

+    __r0 = __r0 * __ll_B | __ll_lowpart (n0);				\

+    if (__r0 < __m)							\

+      { 								\

+	__q0--, __r0 += (d);						\

+	if (__r0 >= (d))						\

+	  if (__r0 < __m)						\

+	    __q0--, __r0 += (d);					\

+      } 								\

+    __r0 -= __m;							\

+									\

+    (q) = (UWtype) __q1 * __ll_B | __q0;				\

+    (r) = __r0; 							\

+  } while (0)

+

+/* If the processor has no udiv_qrnnd but sdiv_qrnnd, go through

+   __udiv_w_sdiv (defined in libgcc or elsewhere).  */

+#if !defined (udiv_qrnnd) && defined (sdiv_qrnnd)

+#define udiv_qrnnd(q, r, nh, nl, d) \

+  do {									\

+    UWtype __r; 							\

+    (q) = __MPN(udiv_w_sdiv) (&__r, nh, nl, d); 			\

+    (r) = __r;								\

+  } while (0)

+#endif

+

+/* If udiv_qrnnd was not defined for this processor, use __udiv_qrnnd_c.  */

+#if !defined (udiv_qrnnd)

+#define UDIV_NEEDS_NORMALIZATION 1

+#define udiv_qrnnd __udiv_qrnnd_c

+#endif

+

+#if !defined (count_leading_zeros)

+extern

+#ifdef __STDC__

+const

+#endif

+unsigned char _gcry_clz_tab[];

+#define MPI_INTERNAL_NEED_CLZ_TAB 1

+#define count_leading_zeros(count, x) \

+  do {									\

+    UWtype __xr = (x);							\

+    UWtype __a; 							\

+									\

+    if (W_TYPE_SIZE <= 32)						\

+      { 								\

+	__a = __xr < ((UWtype) 1 << 2*__BITS4)				\

+	  ? (__xr < ((UWtype) 1 << __BITS4) ? 0 : __BITS4)		\

+	  : (__xr < ((UWtype) 1 << 3*__BITS4) ?  2*__BITS4 : 3*__BITS4);\

+      } 								\

+    else								\

+      { 								\

+	for (__a = W_TYPE_SIZE - 8; __a > 0; __a -= 8)			\

+	  if (((__xr >> __a) & 0xff) != 0)				\

+	    break;							\

+      } 								\

+									\

+    (count) = W_TYPE_SIZE - (_gcry_clz_tab[__xr >> __a] + __a);		\

+  } while (0)

+/* This version gives a well-defined value for zero. */

+#define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE

+#endif

+

+#if !defined (count_trailing_zeros)

+/* Define count_trailing_zeros using count_leading_zeros.  The latter might be

+   defined in asm, but if it is not, the C version above is good enough.  */

+#define count_trailing_zeros(count, x) \

+  do {									\

+    UWtype __ctz_x = (x);						\

+    UWtype __ctz_c;							\

+    count_leading_zeros (__ctz_c, __ctz_x & -__ctz_x);			\

+    (count) = W_TYPE_SIZE - 1 - __ctz_c;				\

+  } while (0)

+#endif

+

+#ifndef UDIV_NEEDS_NORMALIZATION

+#define UDIV_NEEDS_NORMALIZATION 0

+#endif

diff --git a/libgcrypt-1.4.6/mpi/mpi-bit.c b/libgcrypt-1.4.6/mpi/mpi-bit.c
index 32c820c..6c59fc0 100644
--- a/libgcrypt-1.4.6/mpi/mpi-bit.c
+++ b/libgcrypt-1.4.6/mpi/mpi-bit.c
@@ -1,365 +1,365 @@
-/* mpi-bit.c  -  MPI bit level fucntions
- * Copyright (C) 1998, 1999, 2001, 2002, 2006 Free Software Foundation, Inc.
- *
- * This file is part of Libgcrypt.
- *
- * Libgcrypt is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * Libgcrypt is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "mpi-internal.h"
-#include "longlong.h"
-
-
-#ifdef MPI_INTERNAL_NEED_CLZ_TAB
-#ifdef __STDC__
-const
-#endif
-unsigned char
-_gcry_clz_tab[] =
-{
-  0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-};
-#endif
-
-
-#define A_LIMB_1 ((mpi_limb_t)1)
-
-
-/****************
- * Sometimes we have MSL (most significant limbs) which are 0;
- * this is for some reasons not good, so this function removes them.
- */
-void
-_gcry_mpi_normalize( gcry_mpi_t a )
-{
-    if( mpi_is_opaque(a) )
-	return;
-
-    for( ; a->nlimbs && !a->d[a->nlimbs-1]; a->nlimbs-- )
-	;
-}
-
-
-
-/****************
- * Return the number of bits in A.
- */
-unsigned int
-gcry_mpi_get_nbits( gcry_mpi_t a )
-{
-    unsigned n;
-
-    if( mpi_is_opaque(a) ) {
-	return a->sign; /* which holds the number of bits */
-    }
-
-    _gcry_mpi_normalize( a );
-    if( a->nlimbs ) {
-	mpi_limb_t alimb = a->d[a->nlimbs-1];
-	if( alimb )
-	    count_leading_zeros( n, alimb );
-	else
-	    n = BITS_PER_MPI_LIMB;
-	n = BITS_PER_MPI_LIMB - n + (a->nlimbs-1) * BITS_PER_MPI_LIMB;
-    }
-    else
-	n = 0;
-    return n;
-}
-
-
-/****************
- * Test whether bit N is set.
- */
-int
-gcry_mpi_test_bit( gcry_mpi_t a, unsigned int n )
-{
-    unsigned int limbno, bitno;
-    mpi_limb_t limb;
-
-    limbno = n / BITS_PER_MPI_LIMB;
-    bitno  = n % BITS_PER_MPI_LIMB;
-
-    if( limbno >= a->nlimbs )
-	return 0; /* too far left: this is a 0 */
-    limb = a->d[limbno];
-    return (limb & (A_LIMB_1 << bitno))? 1: 0;
-}
-
-
-/****************
- * Set bit N of A.
- */
-void
-gcry_mpi_set_bit( gcry_mpi_t a, unsigned int n )
-{
-  unsigned int limbno, bitno;
-
-  limbno = n / BITS_PER_MPI_LIMB;
-  bitno  = n % BITS_PER_MPI_LIMB;
-
-  if ( limbno >= a->nlimbs ) 
-    {
-      mpi_resize (a, limbno+1 );
-      a->nlimbs = limbno+1;
-    }
-  a->d[limbno] |= (A_LIMB_1<<bitno);
-}
-
-/****************
- * Set bit N of A. and clear all bits above
- */
-void
-gcry_mpi_set_highbit( gcry_mpi_t a, unsigned int n )
-{
-  unsigned int limbno, bitno;
-  
-  limbno = n / BITS_PER_MPI_LIMB;
-  bitno  = n % BITS_PER_MPI_LIMB;
-  
-  if ( limbno >= a->nlimbs ) 
-    { 
-      mpi_resize (a, limbno+1 );
-      a->nlimbs = limbno+1;
-    }
-  a->d[limbno] |= (A_LIMB_1<<bitno);
-  for ( bitno++; bitno < BITS_PER_MPI_LIMB; bitno++ )
-    a->d[limbno] &= ~(A_LIMB_1 << bitno);
-  a->nlimbs = limbno+1;
-}
-
-/****************
- * clear bit N of A and all bits above
- */
-void
-gcry_mpi_clear_highbit( gcry_mpi_t a, unsigned int n )
-{
-    unsigned int limbno, bitno;
-
-    limbno = n / BITS_PER_MPI_LIMB;
-    bitno  = n % BITS_PER_MPI_LIMB;
-
-    if( limbno >= a->nlimbs )
-	return; /* not allocated, therefore no need to clear bits
-		   :-) */
-
-    for( ; bitno < BITS_PER_MPI_LIMB; bitno++ )
-	a->d[limbno] &= ~(A_LIMB_1 << bitno);
-    a->nlimbs = limbno+1;
-}
-
-/****************
- * Clear bit N of A.
- */
-void
-gcry_mpi_clear_bit( gcry_mpi_t a, unsigned int n )
-{
-    unsigned int limbno, bitno;
-
-    limbno = n / BITS_PER_MPI_LIMB;
-    bitno  = n % BITS_PER_MPI_LIMB;
-
-    if( limbno >= a->nlimbs )
-	return; /* don't need to clear this bit, it's to far to left */
-    a->d[limbno] &= ~(A_LIMB_1 << bitno);
-}
-
-
-/****************
- * Shift A by COUNT limbs to the right
- * This is used only within the MPI library
- */
-void
-_gcry_mpi_rshift_limbs( gcry_mpi_t a, unsigned int count )
-{
-    mpi_ptr_t ap = a->d;
-    mpi_size_t n = a->nlimbs;
-    unsigned int i;
-
-    if( count >= n ) {
-	a->nlimbs = 0;
-	return;
-    }
-
-    for( i = 0; i < n - count; i++ )
-	ap[i] = ap[i+count];
-    ap[i] = 0;
-    a->nlimbs -= count;
-}
-
-
-/*
- * Shift A by N bits to the right.
- */
-void
-gcry_mpi_rshift ( gcry_mpi_t x, gcry_mpi_t a, unsigned int n )
-{
-  mpi_size_t xsize;
-  unsigned int i;
-  unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);
-  unsigned int nbits = (n%BITS_PER_MPI_LIMB);
-
-  if ( x == a )
-    {
-      /* In-place operation.  */
-      if ( nlimbs >= x->nlimbs )
-        {
-          x->nlimbs = 0;
-          return;
-        }
-
-      if (nlimbs)
-        {
-          for (i=0; i < x->nlimbs - nlimbs; i++ )
-            x->d[i] = x->d[i+nlimbs];
-          x->d[i] = 0;
-          x->nlimbs -= nlimbs;
-
-        }
-      if ( x->nlimbs && nbits )
-        _gcry_mpih_rshift ( x->d, x->d, x->nlimbs, nbits );
-    }
-  else if ( nlimbs )
-    {
-      /* Copy and shift by more or equal bits than in a limb. */
-      xsize = a->nlimbs;
-      x->sign = a->sign;
-      RESIZE_IF_NEEDED (x, xsize);
-      x->nlimbs = xsize;
-      for (i=0; i < a->nlimbs; i++ )
-        x->d[i] = a->d[i];
-      x->nlimbs = i;
-
-      if ( nlimbs >= x->nlimbs )
-        {
-          x->nlimbs = 0;
-          return;
-        }
-
-      if (nlimbs)
-        {
-          for (i=0; i < x->nlimbs - nlimbs; i++ )
-            x->d[i] = x->d[i+nlimbs];
-          x->d[i] = 0;
-          x->nlimbs -= nlimbs;
-        }
-
-      if ( x->nlimbs && nbits )
-        _gcry_mpih_rshift ( x->d, x->d, x->nlimbs, nbits );
-    }
-  else
-    {
-      /* Copy and shift by less than bits in a limb.  */
-      xsize = a->nlimbs;
-      x->sign = a->sign;
-      RESIZE_IF_NEEDED (x, xsize);
-      x->nlimbs = xsize;
-      
-      if ( xsize )
-        {
-          if (nbits )
-            _gcry_mpih_rshift (x->d, a->d, x->nlimbs, nbits );
-          else
-            {
-              /* The rshift helper function is not specified for
-                 NBITS==0, thus we do a plain copy here. */
-              for (i=0; i < x->nlimbs; i++ )
-                x->d[i] = a->d[i];
-            }
-        }
-    }
-  MPN_NORMALIZE (x->d, x->nlimbs);
-}
-
-
-/****************
- * Shift A by COUNT limbs to the left
- * This is used only within the MPI library
- */
-void
-_gcry_mpi_lshift_limbs (gcry_mpi_t a, unsigned int count)
-{
-  mpi_ptr_t ap;
-  int n = a->nlimbs;
-  int i;
-
-  if (!count || !n)
-    return;
-
-  RESIZE_IF_NEEDED (a, n+count);
-
-  ap = a->d;
-  for (i = n-1; i >= 0; i--)
-    ap[i+count] = ap[i];
-  for (i=0; i < count; i++ )
-    ap[i] = 0;
-  a->nlimbs += count;
-}
-
-
-/*
- * Shift A by N bits to the left.
- */
-void
-gcry_mpi_lshift ( gcry_mpi_t x, gcry_mpi_t a, unsigned int n )
-{
-  unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);
-  unsigned int nbits = (n%BITS_PER_MPI_LIMB);
-
-  if (x == a && !n)
-    return;  /* In-place shift with an amount of zero.  */
-
-  if ( x != a )
-    {
-      /* Copy A to X.  */
-      unsigned int alimbs = a->nlimbs;
-      int asign  = a->sign;
-      mpi_ptr_t xp, ap;
-
-      RESIZE_IF_NEEDED (x, alimbs+nlimbs+1);
-      xp = x->d;
-      ap = a->d;
-      MPN_COPY (xp, ap, alimbs);
-      x->nlimbs = alimbs;
-      x->flags = a->flags;
-      x->sign = asign;
-    }
-
-  if (nlimbs && !nbits)
-    {
-      /* Shift a full number of limbs.  */
-      _gcry_mpi_lshift_limbs (x, nlimbs);
-    }
-  else if (n)
-    {
-      /* We use a very dump approach: Shift left by the number of
-         limbs plus one and than fix it up by an rshift.  */
-      _gcry_mpi_lshift_limbs (x, nlimbs+1);
-      gcry_mpi_rshift (x, x, BITS_PER_MPI_LIMB - nbits);
-    }
-
-  MPN_NORMALIZE (x->d, x->nlimbs);
-}
-
+/* mpi-bit.c  -  MPI bit level functions

+ * Copyright (C) 1998, 1999, 2001, 2002, 2006 Free Software Foundation, Inc.

+ *

+ * This file is part of Libgcrypt.

+ *

+ * Libgcrypt is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU Lesser General Public License as

+ * published by the Free Software Foundation; either version 2.1 of

+ * the License, or (at your option) any later version.

+ *

+ * Libgcrypt is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

+ */

+

+#include <config.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include "mpi-internal.h"

+#include "longlong.h"

+

+

+#ifdef MPI_INTERNAL_NEED_CLZ_TAB

+#ifdef __STDC__

+const

+#endif

+unsigned char

+_gcry_clz_tab[] =

+{

+  0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,

+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,

+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,

+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,

+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+  8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,

+};

+#endif

+

+

+#define A_LIMB_1 ((mpi_limb_t)1)

+

+

+/****************

+ * Sometimes we have MSL (most significant limbs) which are 0;

+ * this is for some reasons not good, so this function removes them.

+ */

+void

+_gcry_mpi_normalize( gcry_mpi_t a )

+{

+    if( mpi_is_opaque(a) )

+	return;

+

+    for( ; a->nlimbs && !a->d[a->nlimbs-1]; a->nlimbs-- )

+	;

+}

+

+

+

+/****************

+ * Return the number of bits in A.

+ */

+unsigned int

+gcry_mpi_get_nbits( gcry_mpi_t a )

+{

+    unsigned n;

+

+    if( mpi_is_opaque(a) ) {

+	return a->sign; /* which holds the number of bits */

+    }

+

+    _gcry_mpi_normalize( a );

+    if( a->nlimbs ) {

+	mpi_limb_t alimb = a->d[a->nlimbs-1];

+	if( alimb )

+	    count_leading_zeros( n, alimb );

+	else

+	    n = BITS_PER_MPI_LIMB;

+	n = BITS_PER_MPI_LIMB - n + (a->nlimbs-1) * BITS_PER_MPI_LIMB;

+    }

+    else

+	n = 0;

+    return n;

+}

+

+

+/****************

+ * Test whether bit N is set.

+ */

+int

+gcry_mpi_test_bit( gcry_mpi_t a, unsigned int n )

+{

+    unsigned int limbno, bitno;

+    mpi_limb_t limb;

+

+    limbno = n / BITS_PER_MPI_LIMB;

+    bitno  = n % BITS_PER_MPI_LIMB;

+

+    if( limbno >= a->nlimbs )

+	return 0; /* too far left: this is a 0 */

+    limb = a->d[limbno];

+    return (limb & (A_LIMB_1 << bitno))? 1: 0;

+}

+

+

+/****************

+ * Set bit N of A.

+ */

+void

+gcry_mpi_set_bit( gcry_mpi_t a, unsigned int n )

+{

+  unsigned int limbno, bitno;

+

+  limbno = n / BITS_PER_MPI_LIMB;

+  bitno  = n % BITS_PER_MPI_LIMB;

+

+  if ( limbno >= a->nlimbs ) 

+    {

+      mpi_resize (a, limbno+1 );

+      a->nlimbs = limbno+1;

+    }

+  a->d[limbno] |= (A_LIMB_1<<bitno);

+}

+

+/****************

+ * Set bit N of A. and clear all bits above

+ */

+void

+gcry_mpi_set_highbit( gcry_mpi_t a, unsigned int n )

+{

+  unsigned int limbno, bitno;

+  

+  limbno = n / BITS_PER_MPI_LIMB;

+  bitno  = n % BITS_PER_MPI_LIMB;

+  

+  if ( limbno >= a->nlimbs ) 

+    { 

+      mpi_resize (a, limbno+1 );

+      a->nlimbs = limbno+1;

+    }

+  a->d[limbno] |= (A_LIMB_1<<bitno);

+  for ( bitno++; bitno < BITS_PER_MPI_LIMB; bitno++ )

+    a->d[limbno] &= ~(A_LIMB_1 << bitno);

+  a->nlimbs = limbno+1;

+}

+

+/****************

+ * clear bit N of A and all bits above

+ */

+void

+gcry_mpi_clear_highbit( gcry_mpi_t a, unsigned int n )

+{

+    unsigned int limbno, bitno;

+

+    limbno = n / BITS_PER_MPI_LIMB;

+    bitno  = n % BITS_PER_MPI_LIMB;

+

+    if( limbno >= a->nlimbs )

+	return; /* not allocated, therefore no need to clear bits

+		   :-) */

+

+    for( ; bitno < BITS_PER_MPI_LIMB; bitno++ )

+	a->d[limbno] &= ~(A_LIMB_1 << bitno);

+    a->nlimbs = limbno+1;

+}

+

+/****************

+ * Clear bit N of A.

+ */

+void

+gcry_mpi_clear_bit( gcry_mpi_t a, unsigned int n )

+{

+    unsigned int limbno, bitno;

+

+    limbno = n / BITS_PER_MPI_LIMB;

+    bitno  = n % BITS_PER_MPI_LIMB;

+

+    if( limbno >= a->nlimbs )

+	return; /* don't need to clear this bit, it's to far to left */

+    a->d[limbno] &= ~(A_LIMB_1 << bitno);

+}

+

+

+/****************

+ * Shift A by COUNT limbs to the right

+ * This is used only within the MPI library

+ */

+void

+_gcry_mpi_rshift_limbs( gcry_mpi_t a, unsigned int count )

+{

+    mpi_ptr_t ap = a->d;

+    mpi_size_t n = a->nlimbs;

+    unsigned int i;

+

+    if( count >= n ) {

+	a->nlimbs = 0;

+	return;

+    }

+

+    for( i = 0; i < n - count; i++ )

+	ap[i] = ap[i+count];

+    ap[i] = 0;

+    a->nlimbs -= count;

+}

+

+

+/*

+ * Shift A by N bits to the right.

+ */

+void

+gcry_mpi_rshift ( gcry_mpi_t x, gcry_mpi_t a, unsigned int n )

+{

+  mpi_size_t xsize;

+  unsigned int i;

+  unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);

+  unsigned int nbits = (n%BITS_PER_MPI_LIMB);

+

+  if ( x == a )

+    {

+      /* In-place operation.  */

+      if ( nlimbs >= x->nlimbs )

+        {

+          x->nlimbs = 0;

+          return;

+        }

+

+      if (nlimbs)

+        {

+          for (i=0; i < x->nlimbs - nlimbs; i++ )

+            x->d[i] = x->d[i+nlimbs];

+          x->d[i] = 0;

+          x->nlimbs -= nlimbs;

+

+        }

+      if ( x->nlimbs && nbits )

+        _gcry_mpih_rshift ( x->d, x->d, x->nlimbs, nbits );

+    }

+  else if ( nlimbs )

+    {

+      /* Copy and shift by more or equal bits than in a limb. */

+      xsize = a->nlimbs;

+      x->sign = a->sign;

+      RESIZE_IF_NEEDED (x, xsize);

+      x->nlimbs = xsize;

+      for (i=0; i < a->nlimbs; i++ )

+        x->d[i] = a->d[i];

+      x->nlimbs = i;

+

+      if ( nlimbs >= x->nlimbs )

+        {

+          x->nlimbs = 0;

+          return;

+        }

+

+      if (nlimbs)

+        {

+          for (i=0; i < x->nlimbs - nlimbs; i++ )

+            x->d[i] = x->d[i+nlimbs];

+          x->d[i] = 0;

+          x->nlimbs -= nlimbs;

+        }

+

+      if ( x->nlimbs && nbits )

+        _gcry_mpih_rshift ( x->d, x->d, x->nlimbs, nbits );

+    }

+  else

+    {

+      /* Copy and shift by less than bits in a limb.  */

+      xsize = a->nlimbs;

+      x->sign = a->sign;

+      RESIZE_IF_NEEDED (x, xsize);

+      x->nlimbs = xsize;

+      

+      if ( xsize )

+        {

+          if (nbits )

+            _gcry_mpih_rshift (x->d, a->d, x->nlimbs, nbits );

+          else

+            {

+              /* The rshift helper function is not specified for

+                 NBITS==0, thus we do a plain copy here. */

+              for (i=0; i < x->nlimbs; i++ )

+                x->d[i] = a->d[i];

+            }

+        }

+    }

+  MPN_NORMALIZE (x->d, x->nlimbs);

+}

+

+

+/****************

+ * Shift A by COUNT limbs to the left

+ * This is used only within the MPI library

+ */

+void

+_gcry_mpi_lshift_limbs (gcry_mpi_t a, unsigned int count)

+{

+  mpi_ptr_t ap;

+  int n = a->nlimbs;

+  int i;

+

+  if (!count || !n)

+    return;

+

+  RESIZE_IF_NEEDED (a, n+count);

+

+  ap = a->d;

+  for (i = n-1; i >= 0; i--)

+    ap[i+count] = ap[i];

+  for (i=0; i < count; i++ )

+    ap[i] = 0;

+  a->nlimbs += count;

+}

+

+

+/*

+ * Shift A by N bits to the left.

+ */

+void

+gcry_mpi_lshift ( gcry_mpi_t x, gcry_mpi_t a, unsigned int n )

+{

+  unsigned int nlimbs = (n/BITS_PER_MPI_LIMB);

+  unsigned int nbits = (n%BITS_PER_MPI_LIMB);

+

+  if (x == a && !n)

+    return;  /* In-place shift with an amount of zero.  */

+

+  if ( x != a )

+    {

+      /* Copy A to X.  */

+      unsigned int alimbs = a->nlimbs;

+      int asign  = a->sign;

+      mpi_ptr_t xp, ap;

+

+      RESIZE_IF_NEEDED (x, alimbs+nlimbs+1);

+      xp = x->d;

+      ap = a->d;

+      MPN_COPY (xp, ap, alimbs);

+      x->nlimbs = alimbs;

+      x->flags = a->flags;

+      x->sign = asign;

+    }

+

+  if (nlimbs && !nbits)

+    {

+      /* Shift a full number of limbs.  */

+      _gcry_mpi_lshift_limbs (x, nlimbs);

+    }

+  else if (n)

+    {

+      /* We use a very dump approach: Shift left by the number of

+         limbs plus one and than fix it up by an rshift.  */

+      _gcry_mpi_lshift_limbs (x, nlimbs+1);

+      gcry_mpi_rshift (x, x, BITS_PER_MPI_LIMB - nbits);

+    }

+

+  MPN_NORMALIZE (x->d, x->nlimbs);

+}

+

diff --git a/libgcrypt-1.4.6/mpi/mpi-div.c b/libgcrypt-1.4.6/mpi/mpi-div.c
index 0d8a2d1..e94e531 100644
--- a/libgcrypt-1.4.6/mpi/mpi-div.c
+++ b/libgcrypt-1.4.6/mpi/mpi-div.c
@@ -1,358 +1,358 @@
-/* mpi-div.c  -  MPI functions
- * Copyright (C) 1994, 1996, 1998, 2001, 2002,
- *               2003 Free Software Foundation, Inc.
- *
- * This file is part of Libgcrypt.
- *
- * Libgcrypt is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * Libgcrypt is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- *
- * Note: This code is heavily based on the GNU MP Library.
- *	 Actually it's the same code with only minor changes in the
- *	 way the data is stored; this is to support the abstraction
- *	 of an optional secure memory allocation which may be used
- *	 to avoid revealing of sensitive data due to paging etc.
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "mpi-internal.h"
-#include "longlong.h"
-#include "g10lib.h"
-
-
-void
-_gcry_mpi_fdiv_r( gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor )
-{
-    int divisor_sign = divisor->sign;
-    gcry_mpi_t temp_divisor = NULL;
-
-    /* We need the original value of the divisor after the remainder has been
-     * preliminary calculated.	We have to copy it to temporary space if it's
-     * the same variable as REM.  */
-    if( rem == divisor ) {
-	temp_divisor = mpi_copy( divisor );
-	divisor = temp_divisor;
-    }
-
-    _gcry_mpi_tdiv_r( rem, dividend, divisor );
-
-    if( ((divisor_sign?1:0) ^ (dividend->sign?1:0)) && rem->nlimbs )
-	gcry_mpi_add( rem, rem, divisor);
-
-    if( temp_divisor )
-	mpi_free(temp_divisor);
-}
-
-
-
-/****************
- * Division rounding the quotient towards -infinity.
- * The remainder gets the same sign as the denominator.
- * rem is optional
- */
-
-ulong
-_gcry_mpi_fdiv_r_ui( gcry_mpi_t rem, gcry_mpi_t dividend, ulong divisor )
-{
-    mpi_limb_t rlimb;
-
-    rlimb = _gcry_mpih_mod_1( dividend->d, dividend->nlimbs, divisor );
-    if( rlimb && dividend->sign )
-	rlimb = divisor - rlimb;
-
-    if( rem ) {
-	rem->d[0] = rlimb;
-	rem->nlimbs = rlimb? 1:0;
-    }
-    return rlimb;
-}
-
-
-void
-_gcry_mpi_fdiv_q( gcry_mpi_t quot, gcry_mpi_t dividend, gcry_mpi_t divisor )
-{
-    gcry_mpi_t tmp = mpi_alloc( mpi_get_nlimbs(quot) );
-    _gcry_mpi_fdiv_qr( quot, tmp, dividend, divisor);
-    mpi_free(tmp);
-}
-
-void
-_gcry_mpi_fdiv_qr( gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor )
-{
-    int divisor_sign = divisor->sign;
-    gcry_mpi_t temp_divisor = NULL;
-
-    if( quot == divisor || rem == divisor ) {
-	temp_divisor = mpi_copy( divisor );
-	divisor = temp_divisor;
-    }
-
-    _gcry_mpi_tdiv_qr( quot, rem, dividend, divisor );
-
-    if( (divisor_sign ^ dividend->sign) && rem->nlimbs ) {
-	gcry_mpi_sub_ui( quot, quot, 1 );
-	gcry_mpi_add( rem, rem, divisor);
-    }
-
-    if( temp_divisor )
-	mpi_free(temp_divisor);
-}
-
-
-/* If den == quot, den needs temporary storage.
- * If den == rem, den needs temporary storage.
- * If num == quot, num needs temporary storage.
- * If den has temporary storage, it can be normalized while being copied,
- *   i.e no extra storage should be allocated.
- */
-
-void
-_gcry_mpi_tdiv_r( gcry_mpi_t rem, gcry_mpi_t num, gcry_mpi_t den)
-{
-    _gcry_mpi_tdiv_qr(NULL, rem, num, den );
-}
-
-void
-_gcry_mpi_tdiv_qr( gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t num, gcry_mpi_t den)
-{
-    mpi_ptr_t np, dp;
-    mpi_ptr_t qp, rp;
-    mpi_size_t nsize = num->nlimbs;
-    mpi_size_t dsize = den->nlimbs;
-    mpi_size_t qsize, rsize;
-    mpi_size_t sign_remainder = num->sign;
-    mpi_size_t sign_quotient = num->sign ^ den->sign;
-    unsigned normalization_steps;
-    mpi_limb_t q_limb;
-    mpi_ptr_t marker[5];
-    unsigned int marker_nlimbs[5];
-    int markidx=0;
-
-    /* Ensure space is enough for quotient and remainder.
-     * We need space for an extra limb in the remainder, because it's
-     * up-shifted (normalized) below.  */
-    rsize = nsize + 1;
-    mpi_resize( rem, rsize);
-
-    qsize = rsize - dsize;	  /* qsize cannot be bigger than this.	*/
-    if( qsize <= 0 ) {
-	if( num != rem ) {
-	    rem->nlimbs = num->nlimbs;
-	    rem->sign = num->sign;
-	    MPN_COPY(rem->d, num->d, nsize);
-	}
-	if( quot ) {
-	    /* This needs to follow the assignment to rem, in case the
-	     * numerator and quotient are the same.  */
-	    quot->nlimbs = 0;
-	    quot->sign = 0;
-	}
-	return;
-    }
-
-    if( quot )
-	mpi_resize( quot, qsize);
-
-    /* Read pointers here, when reallocation is finished.  */
-    np = num->d;
-    dp = den->d;
-    rp = rem->d;
-
-    /* Optimize division by a single-limb divisor.  */
-    if( dsize == 1 ) {
-	mpi_limb_t rlimb;
-	if( quot ) {
-	    qp = quot->d;
-	    rlimb = _gcry_mpih_divmod_1( qp, np, nsize, dp[0] );
-	    qsize -= qp[qsize - 1] == 0;
-	    quot->nlimbs = qsize;
-	    quot->sign = sign_quotient;
-	}
-	else
-	    rlimb = _gcry_mpih_mod_1( np, nsize, dp[0] );
-	rp[0] = rlimb;
-	rsize = rlimb != 0?1:0;
-	rem->nlimbs = rsize;
-	rem->sign = sign_remainder;
-	return;
-    }
-
-
-    if( quot ) {
-	qp = quot->d;
-	/* Make sure QP and NP point to different objects.  Otherwise the
-	 * numerator would be gradually overwritten by the quotient limbs.  */
-	if(qp == np) { /* Copy NP object to temporary space.  */
-            marker_nlimbs[markidx] = nsize;
-	    np = marker[markidx++] = mpi_alloc_limb_space(nsize,
-							  mpi_is_secure(quot));
-	    MPN_COPY(np, qp, nsize);
-	}
-    }
-    else /* Put quotient at top of remainder. */
-	qp = rp + dsize;
-
-    count_leading_zeros( normalization_steps, dp[dsize - 1] );
-
-    /* Normalize the denominator, i.e. make its most significant bit set by
-     * shifting it NORMALIZATION_STEPS bits to the left.  Also shift the
-     * numerator the same number of steps (to keep the quotient the same!).
-     */
-    if( normalization_steps ) {
-	mpi_ptr_t tp;
-	mpi_limb_t nlimb;
-
-	/* Shift up the denominator setting the most significant bit of
-	 * the most significant word.  Use temporary storage not to clobber
-	 * the original contents of the denominator.  */
-        marker_nlimbs[markidx] = dsize;
-	tp = marker[markidx++] = mpi_alloc_limb_space(dsize,mpi_is_secure(den));
-	_gcry_mpih_lshift( tp, dp, dsize, normalization_steps );
-	dp = tp;
-
-	/* Shift up the numerator, possibly introducing a new most
-	 * significant word.  Move the shifted numerator in the remainder
-	 * meanwhile.  */
-	nlimb = _gcry_mpih_lshift(rp, np, nsize, normalization_steps);
-	if( nlimb ) {
-	    rp[nsize] = nlimb;
-	    rsize = nsize + 1;
-	}
-	else
-	    rsize = nsize;
-    }
-    else {
-	/* The denominator is already normalized, as required.	Copy it to
-	 * temporary space if it overlaps with the quotient or remainder.  */
-	if( dp == rp || (quot && (dp == qp))) {
-	    mpi_ptr_t tp;
-
-            marker_nlimbs[markidx] = dsize;
-	    tp = marker[markidx++] = mpi_alloc_limb_space(dsize,
-                                                          mpi_is_secure(den));
-	    MPN_COPY( tp, dp, dsize );
-	    dp = tp;
-	}
-
-	/* Move the numerator to the remainder.  */
-	if( rp != np )
-	    MPN_COPY(rp, np, nsize);
-
-	rsize = nsize;
-    }
-
-    q_limb = _gcry_mpih_divrem( qp, 0, rp, rsize, dp, dsize );
-
-    if( quot ) {
-	qsize = rsize - dsize;
-	if(q_limb) {
-	    qp[qsize] = q_limb;
-	    qsize += 1;
-	}
-
-	quot->nlimbs = qsize;
-	quot->sign = sign_quotient;
-    }
-
-    rsize = dsize;
-    MPN_NORMALIZE (rp, rsize);
-
-    if( normalization_steps && rsize ) {
-	_gcry_mpih_rshift(rp, rp, rsize, normalization_steps);
-	rsize -= rp[rsize - 1] == 0?1:0;
-    }
-
-    rem->nlimbs = rsize;
-    rem->sign	= sign_remainder;
-    while( markidx )
-      {
-        markidx--;
-	_gcry_mpi_free_limb_space (marker[markidx], marker_nlimbs[markidx]);
-      }
-}
-
-void
-_gcry_mpi_tdiv_q_2exp( gcry_mpi_t w, gcry_mpi_t u, unsigned int count )
-{
-    mpi_size_t usize, wsize;
-    mpi_size_t limb_cnt;
-
-    usize = u->nlimbs;
-    limb_cnt = count / BITS_PER_MPI_LIMB;
-    wsize = usize - limb_cnt;
-    if( limb_cnt >= usize )
-	w->nlimbs = 0;
-    else {
-	mpi_ptr_t wp;
-	mpi_ptr_t up;
-
-	RESIZE_IF_NEEDED( w, wsize );
-	wp = w->d;
-	up = u->d;
-
-	count %= BITS_PER_MPI_LIMB;
-	if( count ) {
-	    _gcry_mpih_rshift( wp, up + limb_cnt, wsize, count );
-	    wsize -= !wp[wsize - 1];
-	}
-	else {
-	    MPN_COPY_INCR( wp, up + limb_cnt, wsize);
-	}
-
-	w->nlimbs = wsize;
-    }
-}
-
-/****************
- * Check whether dividend is divisible by divisor
- * (note: divisor must fit into a limb)
- */
-int
-_gcry_mpi_divisible_ui(gcry_mpi_t dividend, ulong divisor )
-{
-    return !_gcry_mpih_mod_1( dividend->d, dividend->nlimbs, divisor );
-}
-
-
-void
-gcry_mpi_div (gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor, int round)
-{
-  if (!round)
-    {
-      if (!rem)
-        {
-          gcry_mpi_t tmp = mpi_alloc (mpi_get_nlimbs(quot));
-          _gcry_mpi_tdiv_qr (quot, tmp, dividend, divisor);
-          mpi_free (tmp);
-        }
-      else
-        _gcry_mpi_tdiv_qr (quot, rem, dividend, divisor);
-    }
-  else if (round < 0)
-    {
-      if (!rem)
-        _gcry_mpi_fdiv_q (quot, dividend, divisor);
-      else if (!quot)
-        _gcry_mpi_fdiv_r (rem, dividend, divisor);
-      else
-        _gcry_mpi_fdiv_qr (quot, rem, dividend, divisor);
-    }
-  else
-    log_bug ("mpi rounding to ceiling not yet implemented\n");
-}
-
-
-
+/* mpi-div.c  -  MPI functions

+ * Copyright (C) 1994, 1996, 1998, 2001, 2002,

+ *               2003 Free Software Foundation, Inc.

+ *

+ * This file is part of Libgcrypt.

+ *

+ * Libgcrypt is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU Lesser General Public License as

+ * published by the Free Software Foundation; either version 2.1 of

+ * the License, or (at your option) any later version.

+ *

+ * Libgcrypt is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

+ *

+ * Note: This code is heavily based on the GNU MP Library.

+ *	 Actually it's the same code with only minor changes in the

+ *	 way the data is stored; this is to support the abstraction

+ *	 of an optional secure memory allocation which may be used

+ *	 to avoid revealing of sensitive data due to paging etc.

+ */

+

+#include <config.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include "mpi-internal.h"

+#include "longlong.h"

+#include "g10lib.h"

+

+

+void

+_gcry_mpi_fdiv_r( gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor )

+{

+    int divisor_sign = divisor->sign;

+    gcry_mpi_t temp_divisor = NULL;

+

+    /* We need the original value of the divisor after the remainder has been

+     * preliminary calculated.	We have to copy it to temporary space if it's

+     * the same variable as REM.  */

+    if( rem == divisor ) {

+	temp_divisor = mpi_copy( divisor );

+	divisor = temp_divisor;

+    }

+

+    _gcry_mpi_tdiv_r( rem, dividend, divisor );

+

+    if( ((divisor_sign?1:0) ^ (dividend->sign?1:0)) && rem->nlimbs )

+	gcry_mpi_add( rem, rem, divisor);

+

+    if( temp_divisor )

+	mpi_free(temp_divisor);

+}

+

+

+

+/****************

+ * Division rounding the quotient towards -infinity.

+ * The remainder gets the same sign as the denominator.

+ * rem is optional

+ */

+

+ulong

+_gcry_mpi_fdiv_r_ui( gcry_mpi_t rem, gcry_mpi_t dividend, ulong divisor )

+{

+    mpi_limb_t rlimb;

+

+    rlimb = _gcry_mpih_mod_1( dividend->d, dividend->nlimbs, divisor );

+    if( rlimb && dividend->sign )

+	rlimb = divisor - rlimb;

+

+    if( rem ) {

+	rem->d[0] = rlimb;

+	rem->nlimbs = rlimb? 1:0;

+    }

+    return rlimb;

+}

+

+

+void

+_gcry_mpi_fdiv_q( gcry_mpi_t quot, gcry_mpi_t dividend, gcry_mpi_t divisor )

+{

+    gcry_mpi_t tmp = mpi_alloc( mpi_get_nlimbs(quot) );

+    _gcry_mpi_fdiv_qr( quot, tmp, dividend, divisor);

+    mpi_free(tmp);

+}

+

+void

+_gcry_mpi_fdiv_qr( gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor )

+{

+    int divisor_sign = divisor->sign;

+    gcry_mpi_t temp_divisor = NULL;

+

+    if( quot == divisor || rem == divisor ) {

+	temp_divisor = mpi_copy( divisor );

+	divisor = temp_divisor;

+    }

+

+    _gcry_mpi_tdiv_qr( quot, rem, dividend, divisor );

+

+    if( (divisor_sign ^ dividend->sign) && rem->nlimbs ) {

+	gcry_mpi_sub_ui( quot, quot, 1 );

+	gcry_mpi_add( rem, rem, divisor);

+    }

+

+    if( temp_divisor )

+	mpi_free(temp_divisor);

+}

+

+

+/* If den == quot, den needs temporary storage.

+ * If den == rem, den needs temporary storage.

+ * If num == quot, num needs temporary storage.

+ * If den has temporary storage, it can be normalized while being copied,

+ *   i.e no extra storage should be allocated.

+ */

+

+void

+_gcry_mpi_tdiv_r( gcry_mpi_t rem, gcry_mpi_t num, gcry_mpi_t den)

+{

+    _gcry_mpi_tdiv_qr(NULL, rem, num, den );

+}

+

+void

+_gcry_mpi_tdiv_qr( gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t num, gcry_mpi_t den)

+{

+    mpi_ptr_t np, dp;

+    mpi_ptr_t qp, rp;

+    mpi_size_t nsize = num->nlimbs;

+    mpi_size_t dsize = den->nlimbs;

+    mpi_size_t qsize, rsize;

+    mpi_size_t sign_remainder = num->sign;

+    mpi_size_t sign_quotient = num->sign ^ den->sign;

+    unsigned normalization_steps;

+    mpi_limb_t q_limb;

+    mpi_ptr_t marker[5];

+    unsigned int marker_nlimbs[5];

+    int markidx=0;

+

+    /* Ensure space is enough for quotient and remainder.

+     * We need space for an extra limb in the remainder, because it's

+     * up-shifted (normalized) below.  */

+    rsize = nsize + 1;

+    mpi_resize( rem, rsize);

+

+    qsize = rsize - dsize;	  /* qsize cannot be bigger than this.	*/

+    if( qsize <= 0 ) {

+	if( num != rem ) {

+	    rem->nlimbs = num->nlimbs;

+	    rem->sign = num->sign;

+	    MPN_COPY(rem->d, num->d, nsize);

+	}

+	if( quot ) {

+	    /* This needs to follow the assignment to rem, in case the

+	     * numerator and quotient are the same.  */

+	    quot->nlimbs = 0;

+	    quot->sign = 0;

+	}

+	return;

+    }

+

+    if( quot )

+	mpi_resize( quot, qsize);

+

+    /* Read pointers here, when reallocation is finished.  */

+    np = num->d;

+    dp = den->d;

+    rp = rem->d;

+

+    /* Optimize division by a single-limb divisor.  */

+    if( dsize == 1 ) {

+	mpi_limb_t rlimb;

+	if( quot ) {

+	    qp = quot->d;

+	    rlimb = _gcry_mpih_divmod_1( qp, np, nsize, dp[0] );

+	    qsize -= qp[qsize - 1] == 0;

+	    quot->nlimbs = qsize;

+	    quot->sign = sign_quotient;

+	}

+	else

+	    rlimb = _gcry_mpih_mod_1( np, nsize, dp[0] );

+	rp[0] = rlimb;

+	rsize = rlimb != 0?1:0;

+	rem->nlimbs = rsize;

+	rem->sign = sign_remainder;

+	return;

+    }

+

+

+    if( quot ) {

+	qp = quot->d;

+	/* Make sure QP and NP point to different objects.  Otherwise the

+	 * numerator would be gradually overwritten by the quotient limbs.  */

+	if(qp == np) { /* Copy NP object to temporary space.  */

+            marker_nlimbs[markidx] = nsize;

+	    np = marker[markidx++] = mpi_alloc_limb_space(nsize,

+							  mpi_is_secure(quot));

+	    MPN_COPY(np, qp, nsize);

+	}

+    }

+    else /* Put quotient at top of remainder. */

+	qp = rp + dsize;

+

+    count_leading_zeros( normalization_steps, dp[dsize - 1] );

+

+    /* Normalize the denominator, i.e. make its most significant bit set by

+     * shifting it NORMALIZATION_STEPS bits to the left.  Also shift the

+     * numerator the same number of steps (to keep the quotient the same!).

+     */

+    if( normalization_steps ) {

+	mpi_ptr_t tp;

+	mpi_limb_t nlimb;

+

+	/* Shift up the denominator setting the most significant bit of

+	 * the most significant word.  Use temporary storage not to clobber

+	 * the original contents of the denominator.  */

+        marker_nlimbs[markidx] = dsize;

+	tp = marker[markidx++] = mpi_alloc_limb_space(dsize,mpi_is_secure(den));

+	_gcry_mpih_lshift( tp, dp, dsize, normalization_steps );

+	dp = tp;

+

+	/* Shift up the numerator, possibly introducing a new most

+	 * significant word.  Move the shifted numerator in the remainder

+	 * meanwhile.  */

+	nlimb = _gcry_mpih_lshift(rp, np, nsize, normalization_steps);

+	if( nlimb ) {

+	    rp[nsize] = nlimb;

+	    rsize = nsize + 1;

+	}

+	else

+	    rsize = nsize;

+    }

+    else {

+	/* The denominator is already normalized, as required.	Copy it to

+	 * temporary space if it overlaps with the quotient or remainder.  */

+	if( dp == rp || (quot && (dp == qp))) {

+	    mpi_ptr_t tp;

+

+            marker_nlimbs[markidx] = dsize;

+	    tp = marker[markidx++] = mpi_alloc_limb_space(dsize,

+                                                          mpi_is_secure(den));

+	    MPN_COPY( tp, dp, dsize );

+	    dp = tp;

+	}

+

+	/* Move the numerator to the remainder.  */

+	if( rp != np )

+	    MPN_COPY(rp, np, nsize);

+

+	rsize = nsize;

+    }

+

+    q_limb = _gcry_mpih_divrem( qp, 0, rp, rsize, dp, dsize );

+

+    if( quot ) {

+	qsize = rsize - dsize;

+	if(q_limb) {

+	    qp[qsize] = q_limb;

+	    qsize += 1;

+	}

+

+	quot->nlimbs = qsize;

+	quot->sign = sign_quotient;

+    }

+

+    rsize = dsize;

+    MPN_NORMALIZE (rp, rsize);

+

+    if( normalization_steps && rsize ) {

+	_gcry_mpih_rshift(rp, rp, rsize, normalization_steps);

+	rsize -= rp[rsize - 1] == 0?1:0;

+    }

+

+    rem->nlimbs = rsize;

+    rem->sign	= sign_remainder;

+    while( markidx )

+      {

+        markidx--;

+	_gcry_mpi_free_limb_space (marker[markidx], marker_nlimbs[markidx]);

+      }

+}

+

+void

+_gcry_mpi_tdiv_q_2exp( gcry_mpi_t w, gcry_mpi_t u, unsigned int count )

+{

+    mpi_size_t usize, wsize;

+    mpi_size_t limb_cnt;

+

+    usize = u->nlimbs;

+    limb_cnt = count / BITS_PER_MPI_LIMB;

+    wsize = usize - limb_cnt;

+    if( limb_cnt >= usize )

+	w->nlimbs = 0;

+    else {

+	mpi_ptr_t wp;

+	mpi_ptr_t up;

+

+	RESIZE_IF_NEEDED( w, wsize );

+	wp = w->d;

+	up = u->d;

+

+	count %= BITS_PER_MPI_LIMB;

+	if( count ) {

+	    _gcry_mpih_rshift( wp, up + limb_cnt, wsize, count );

+	    wsize -= !wp[wsize - 1];

+	}

+	else {

+	    MPN_COPY_INCR( wp, up + limb_cnt, wsize);

+	}

+

+	w->nlimbs = wsize;

+    }

+}

+

+/****************

+ * Check whether dividend is divisible by divisor

+ * (note: divisor must fit into a limb)

+ */

+int

+_gcry_mpi_divisible_ui(gcry_mpi_t dividend, ulong divisor )

+{

+    return !_gcry_mpih_mod_1( dividend->d, dividend->nlimbs, divisor );

+}

+

+

+void

+gcry_mpi_div (gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor, int round)

+{

+  if (!round)

+    {

+      if (!rem)

+        {

+          gcry_mpi_t tmp = mpi_alloc (mpi_get_nlimbs(quot));

+          _gcry_mpi_tdiv_qr (quot, tmp, dividend, divisor);

+          mpi_free (tmp);

+        }

+      else

+        _gcry_mpi_tdiv_qr (quot, rem, dividend, divisor);

+    }

+  else if (round < 0)

+    {

+      if (!rem)

+        _gcry_mpi_fdiv_q (quot, dividend, divisor);

+      else if (!quot)

+        _gcry_mpi_fdiv_r (rem, dividend, divisor);

+      else

+        _gcry_mpi_fdiv_qr (quot, rem, dividend, divisor);

+    }

+  else

+    log_bug ("mpi rounding to ceiling not yet implemented\n");

+}

+

+

+

diff --git a/libgcrypt-1.4.6/mpi/mpi-scan.c b/libgcrypt-1.4.6/mpi/mpi-scan.c
index 90699cd..3ee09d2 100644
--- a/libgcrypt-1.4.6/mpi/mpi-scan.c
+++ b/libgcrypt-1.4.6/mpi/mpi-scan.c
@@ -1,132 +1,132 @@
-/* mpi-scan.c  -  MPI functions
- *	Copyright (C) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
- *
- * This file is part of Libgcrypt.
- *
- * Libgcrypt is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * Libgcrypt is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "mpi-internal.h"
-#include "longlong.h"
-
-/****************
- * Scan through an mpi and return byte for byte. a -1 is returned to indicate
- * the end of the mpi. Scanning is done from the lsb to the msb, returned
- * values are in the range of 0 .. 255.
- *
- * FIXME: This code is VERY ugly!
- */
-int
-_gcry_mpi_getbyte( gcry_mpi_t a, unsigned idx )
-{
-    int i, j;
-    unsigned n;
-    mpi_ptr_t ap;
-    mpi_limb_t limb;
-
-    ap = a->d;
-    for(n=0,i=0; i < a->nlimbs; i++ ) {
-	limb = ap[i];
-	for( j=0; j < BYTES_PER_MPI_LIMB; j++, n++ )
-	    if( n == idx )
-		return (limb >> j*8) & 0xff;
-    }
-    return -1;
-}
-
-
-/****************
- * Put a value at position IDX into A. idx counts from lsb to msb
- */
-void
-_gcry_mpi_putbyte( gcry_mpi_t a, unsigned idx, int xc )
-{
-    int i, j;
-    unsigned n;
-    mpi_ptr_t ap;
-    mpi_limb_t limb, c;
-
-    c = xc & 0xff;
-    ap = a->d;
-    for(n=0,i=0; i < a->alloced; i++ ) {
-	limb = ap[i];
-	for( j=0; j < BYTES_PER_MPI_LIMB; j++, n++ )
-	    if( n == idx ) {
-	      #if BYTES_PER_MPI_LIMB == 4
-		if( j == 0 )
-		    limb = (limb & 0xffffff00) | c;
-		else if( j == 1 )
-		    limb = (limb & 0xffff00ff) | (c<<8);
-		else if( j == 2 )
-		    limb = (limb & 0xff00ffff) | (c<<16);
-		else
-		    limb = (limb & 0x00ffffff) | (c<<24);
-	      #elif BYTES_PER_MPI_LIMB == 8
-		if( j == 0 )
-		    limb = (limb & 0xffffffffffffff00) | c;
-		else if( j == 1 )
-		    limb = (limb & 0xffffffffffff00ff) | (c<<8);
-		else if( j == 2 )
-		    limb = (limb & 0xffffffffff00ffff) | (c<<16);
-		else if( j == 3 )
-		    limb = (limb & 0xffffffff00ffffff) | (c<<24);
-		else if( j == 4 )
-		    limb = (limb & 0xffffff00ffffffff) | (c<<32);
-		else if( j == 5 )
-		    limb = (limb & 0xffff00ffffffffff) | (c<<40);
-		else if( j == 6 )
-		    limb = (limb & 0xff00ffffffffffff) | (c<<48);
-		else
-		    limb = (limb & 0x00ffffffffffffff) | (c<<56);
-	      #else
-		 #error please enhance this function, its ugly - i know.
-	      #endif
-		if( a->nlimbs <= i )
-		    a->nlimbs = i+1;
-		ap[i] = limb;
-		return;
-	    }
-    }
-    abort(); /* index out of range */
-}
-
-
-/****************
- * Count the number of zerobits at the low end of A
- */
-unsigned
-_gcry_mpi_trailing_zeros( gcry_mpi_t a )
-{
-    unsigned n, count = 0;
-
-    for(n=0; n < a->nlimbs; n++ ) {
-	if( a->d[n] ) {
-	    unsigned nn;
-	    mpi_limb_t alimb = a->d[n];
-
-	    count_trailing_zeros( nn, alimb );
-	    count += nn;
-	    break;
-	}
-	count += BITS_PER_MPI_LIMB;
-    }
-    return count;
-
-}
-
-
+/* mpi-scan.c  -  MPI functions

+ *	Copyright (C) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.

+ *

+ * This file is part of Libgcrypt.

+ *

+ * Libgcrypt is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU Lesser General Public License as

+ * published by the Free Software Foundation; either version 2.1 of

+ * the License, or (at your option) any later version.

+ *

+ * Libgcrypt is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

+ */

+

+#include <config.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include "mpi-internal.h"

+#include "longlong.h"

+

+/****************

+ * Scan through an mpi and return byte for byte. a -1 is returned to indicate

+ * the end of the mpi. Scanning is done from the lsb to the msb, returned

+ * values are in the range of 0 .. 255.

+ *

+ * FIXME: This code is VERY ugly!

+ */

+int

+_gcry_mpi_getbyte( gcry_mpi_t a, unsigned idx )

+{

+    int i, j;

+    unsigned n;

+    mpi_ptr_t ap;

+    mpi_limb_t limb;

+

+    ap = a->d;

+    for(n=0,i=0; i < a->nlimbs; i++ ) {

+	limb = ap[i];

+	for( j=0; j < BYTES_PER_MPI_LIMB; j++, n++ )

+	    if( n == idx )

+		return (limb >> j*8) & 0xff;

+    }

+    return -1;

+}

+

+

+/****************

+ * Put a value at position IDX into A. idx counts from lsb to msb

+ */

+void

+_gcry_mpi_putbyte( gcry_mpi_t a, unsigned idx, int xc )

+{

+    int i, j;

+    unsigned n;

+    mpi_ptr_t ap;

+    mpi_limb_t limb, c;

+

+    c = xc & 0xff;

+    ap = a->d;

+    for(n=0,i=0; i < a->alloced; i++ ) {

+	limb = ap[i];

+	for( j=0; j < BYTES_PER_MPI_LIMB; j++, n++ )

+	    if( n == idx ) {

+	      #if BYTES_PER_MPI_LIMB == 4

+		if( j == 0 )

+		    limb = (limb & 0xffffff00) | c;

+		else if( j == 1 )

+		    limb = (limb & 0xffff00ff) | (c<<8);

+		else if( j == 2 )

+		    limb = (limb & 0xff00ffff) | (c<<16);

+		else

+		    limb = (limb & 0x00ffffff) | (c<<24);

+	      #elif BYTES_PER_MPI_LIMB == 8

+		if( j == 0 )

+		    limb = (limb & 0xffffffffffffff00) | c;

+		else if( j == 1 )

+		    limb = (limb & 0xffffffffffff00ff) | (c<<8);

+		else if( j == 2 )

+		    limb = (limb & 0xffffffffff00ffff) | (c<<16);

+		else if( j == 3 )

+		    limb = (limb & 0xffffffff00ffffff) | (c<<24);

+		else if( j == 4 )

+		    limb = (limb & 0xffffff00ffffffff) | (c<<32);

+		else if( j == 5 )

+		    limb = (limb & 0xffff00ffffffffff) | (c<<40);

+		else if( j == 6 )

+		    limb = (limb & 0xff00ffffffffffff) | (c<<48);

+		else

+		    limb = (limb & 0x00ffffffffffffff) | (c<<56);

+	      #else

+		 #error please enhance this function, its ugly - i know.

+	      #endif

+		if( a->nlimbs <= i )

+		    a->nlimbs = i+1;

+		ap[i] = limb;

+		return;

+	    }

+    }

+    abort(); /* index out of range */

+}

+

+

+/****************

+ * Count the number of zerobits at the low end of A

+ */

+unsigned

+_gcry_mpi_trailing_zeros( gcry_mpi_t a )

+{

+    unsigned n, count = 0;

+

+    for(n=0; n < a->nlimbs; n++ ) {

+	if( a->d[n] ) {

+	    unsigned nn;

+	    mpi_limb_t alimb = a->d[n];

+

+	    count_trailing_zeros( nn, alimb );

+	    count += nn;

+	    break;

+	}

+	count += BITS_PER_MPI_LIMB;

+    }

+    return count;

+

+}

+

+

diff --git a/libgcrypt-1.4.6/mpi/mpicoder.c b/libgcrypt-1.4.6/mpi/mpicoder.c
index 8f0c76f..b2d542c 100644
--- a/libgcrypt-1.4.6/mpi/mpicoder.c
+++ b/libgcrypt-1.4.6/mpi/mpicoder.c
@@ -1,752 +1,751 @@
-/* mpicoder.c  -  Coder for the external representation of MPIs
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
- *               2008 Free Software Foundation, Inc.
- *
- * This file is part of Libgcrypt.
- *
- * Libgcrypt is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * Libgcrypt is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "mpi-internal.h"
-#include "g10lib.h"
-
-#define MAX_EXTERN_MPI_BITS 16384
-
-/* Helper used to scan PGP style MPIs.  Returns NULL on failure. */
-static gcry_mpi_t
-mpi_read_from_buffer (const unsigned char *buffer, unsigned *ret_nread,
-                      int secure)
-{
-  int i, j;
-  unsigned int nbits, nbytes, nlimbs, nread=0;
-  mpi_limb_t a;
-  gcry_mpi_t val = MPI_NULL;
-  
-  if ( *ret_nread < 2 )
-    goto leave;
-  nbits = buffer[0] << 8 | buffer[1];
-  if ( nbits > MAX_EXTERN_MPI_BITS )
-    {
-/*       log_debug ("mpi too large (%u bits)\n", nbits); */
-      goto leave;
-    }
-  else if( !nbits ) 
-    {
-/*       log_debug ("an mpi of size 0 is not allowed\n"); */
-      goto leave;
-    }
-  buffer += 2;
-  nread = 2;
-
-  nbytes = (nbits+7) / 8;
-  nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB;
-  val = secure? mpi_alloc_secure (nlimbs) : mpi_alloc (nlimbs);
-  i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
-  i %= BYTES_PER_MPI_LIMB;
-  j= val->nlimbs = nlimbs;
-  val->sign = 0;
-  for ( ; j > 0; j-- )
-    {
-      a = 0;
-      for (; i < BYTES_PER_MPI_LIMB; i++ ) 
-        {
-          if ( ++nread > *ret_nread )
-            {
-/*               log_debug ("mpi larger than buffer"); */
-              mpi_free (val);
-              val = NULL;
-              goto leave;
-            }
-          a <<= 8;
-          a |= *buffer++;
-	}
-      i = 0;
-      val->d[j-1] = a;
-    }
-  
- leave:
-  *ret_nread = nread;
-  return val;
-}
-
-
-/****************
- * Fill the mpi VAL from the hex string in STR.
- */
-static int
-mpi_fromstr (gcry_mpi_t val, const char *str)
-{
-  int sign = 0;
-  int prepend_zero = 0;
-  int i, j, c, c1, c2;
-  unsigned int nbits, nbytes, nlimbs;
-  mpi_limb_t a;
-
-  if ( *str == '-' )
-    {
-      sign = 1;
-      str++;
-    }
-
-  /* Skip optional hex prefix.  */
-  if ( *str == '0' && str[1] == 'x' )
-    str += 2;
-
-  nbits = 4 * strlen (str);
-  if ((nbits % 8))
-    prepend_zero = 1;
-
-  nbytes = (nbits+7) / 8;
-  nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB;
-
-  if ( val->alloced < nlimbs )
-    mpi_resize (val, nlimbs);
-
-  i = BYTES_PER_MPI_LIMB - (nbytes % BYTES_PER_MPI_LIMB);
-  i %= BYTES_PER_MPI_LIMB;
-  j = val->nlimbs = nlimbs;
-  val->sign = sign;
-  for (; j > 0; j--)
-    {
-      a = 0;
-      for (; i < BYTES_PER_MPI_LIMB; i++)
-        {
-          if (prepend_zero)
-            {
-              c1 = '0';
-              prepend_zero = 0;
-	    }
-          else
-            c1 = *str++;
-
-          if (!c1)
-            {
-              mpi_clear (val);
-              return 1;  /* Error.  */
-	    }
-          c2 = *str++;
-          if (!c2)
-            {
-              mpi_clear (val);
-              return 1;  /* Error.  */
-	    }
-          if ( c1 >= '0' && c1 <= '9' )
-            c = c1 - '0';
-          else if ( c1 >= 'a' && c1 <= 'f' )
-            c = c1 - 'a' + 10;
-          else if ( c1 >= 'A' && c1 <= 'F' )
-            c = c1 - 'A' + 10;
-          else
-            {
-              mpi_clear (val);
-              return 1;  /* Error.  */
-	    }
-          c <<= 4;
-          if ( c2 >= '0' && c2 <= '9' )
-            c |= c2 - '0';
-          else if( c2 >= 'a' && c2 <= 'f' )
-            c |= c2 - 'a' + 10;
-          else if( c2 >= 'A' && c2 <= 'F' )
-            c |= c2 - 'A' + 10;
-          else 
-            {
-              mpi_clear(val);
-              return 1;  /* Error. */
-	    }
-          a <<= 8;
-          a |= c;
-	}
-      i = 0;
-      val->d[j-1] = a;
-    }
-  
-  return 0;  /* Okay.  */
-}
-
-
-/* Dump the value of A in a format suitable for debugging to
-   Libgcrypt's logging stream.  Note that one leading space but no
-   trailing space or linefeed will be printed.  It is okay to pass
-   NULL for A. */
-void 
-gcry_mpi_dump (const gcry_mpi_t a)
-{
-  int i;
-
-  log_printf (" ");
-  if (!a)
-    log_printf ("[MPI_NULL]");
-  else 
-    {
-      if (a->sign)
-        log_printf ( "-");
-#if BYTES_PER_MPI_LIMB == 2
-# define X "4"
-#elif BYTES_PER_MPI_LIMB == 4
-# define X "8"
-#elif BYTES_PER_MPI_LIMB == 8
-# define X "16"
-#elif BYTES_PER_MPI_LIMB == 16
-# define X "32"
-#else
-# error please define the format here
-#endif
-      for (i=a->nlimbs; i > 0 ; i-- )
-        {
-          log_printf (i != a->nlimbs? "%0" X "lX":"%lX", (ulong)a->d[i-1]);
-        }
-#undef X
-      if (!a->nlimbs)
-        log_printf ("0");
-    }
-}
-
-/* Convience function used internally. */
-void
-_gcry_log_mpidump (const char *text, gcry_mpi_t a)
-{
-  log_printf ("%s:", text);
-  gcry_mpi_dump (a);
-  log_printf ("\n");
-}
-
-
-/* Return an allocated buffer with the MPI (msb first).  NBYTES
-   receives the length of this buffer.  Caller must free the return
-   string.  This function returns an allocated buffer with NBYTES set
-   to zero if the value of A is zero.  If sign is not NULL, it will be
-   set to the sign of the A.  On error NULL is returned and ERRNO set
-   appropriately.  */
-static unsigned char *
-do_get_buffer (gcry_mpi_t a, unsigned int *nbytes, int *sign, int force_secure)
-{
-  unsigned char *p, *buffer;
-  mpi_limb_t alimb;
-  int i;
-  size_t n;
-  
-  if (sign)
-    *sign = a->sign;
-
-  *nbytes = a->nlimbs * BYTES_PER_MPI_LIMB;
-  n = *nbytes? *nbytes:1; /* Allocate at least one byte.  */
-  p = buffer = (force_secure || mpi_is_secure(a))? gcry_malloc_secure (n)
-						 : gcry_malloc (n);
-  if (!buffer)
-    return NULL;
-
-  for (i=a->nlimbs-1; i >= 0; i--)
-    {
-      alimb = a->d[i];
-#if BYTES_PER_MPI_LIMB == 4
-      *p++ = alimb >> 24;
-      *p++ = alimb >> 16;
-      *p++ = alimb >>  8;
-      *p++ = alimb	  ;
-#elif BYTES_PER_MPI_LIMB == 8
-      *p++ = alimb >> 56;
-      *p++ = alimb >> 48;
-      *p++ = alimb >> 40;
-      *p++ = alimb >> 32;
-      *p++ = alimb >> 24;
-      *p++ = alimb >> 16;
-      *p++ = alimb >>  8;
-      *p++ = alimb	  ;
-#else
-#     error please implement for this limb size.
-#endif
-    }
-
-  /* This is sub-optimal but we need to do the shift operation because
-     the caller has to free the returned buffer.  */
-  for (p=buffer; !*p && *nbytes; p++, --*nbytes)
-    ;
-  if (p != buffer)
-    memmove (buffer,p, *nbytes);
-  return buffer;
-}
-
-
-byte *
-_gcry_mpi_get_buffer (gcry_mpi_t a, unsigned int *nbytes, int *sign)
-{
-  return do_get_buffer (a, nbytes, sign, 0);
-}
-
-byte *
-_gcry_mpi_get_secure_buffer (gcry_mpi_t a, unsigned *nbytes, int *sign)
-{
-  return do_get_buffer (a, nbytes, sign, 1);
-}
-
-
-/*
- * Use the NBYTES at BUFFER_ARG to update A.  Set the sign of a to
- * SIGN.
- */
-void
-_gcry_mpi_set_buffer (gcry_mpi_t a, const void *buffer_arg,
-                      unsigned int nbytes, int sign)
-{
-  const unsigned char *buffer = (const unsigned char*)buffer_arg;
-  const unsigned char *p;
-  mpi_limb_t alimb;
-  int nlimbs;
-  int i;
-  
-  nlimbs = (nbytes + BYTES_PER_MPI_LIMB - 1) / BYTES_PER_MPI_LIMB;
-  RESIZE_IF_NEEDED(a, nlimbs);
-  a->sign = sign;
-  
-  for (i=0, p = buffer+nbytes-1; p >= buffer+BYTES_PER_MPI_LIMB; ) 
-    {
-#if BYTES_PER_MPI_LIMB == 4
-      alimb  = *p--	    ;
-      alimb |= *p-- <<  8 ;
-      alimb |= *p-- << 16 ;
-      alimb |= *p-- << 24 ;
-#elif BYTES_PER_MPI_LIMB == 8
-      alimb  = (mpi_limb_t)*p--	;
-      alimb |= (mpi_limb_t)*p-- <<  8 ;
-      alimb |= (mpi_limb_t)*p-- << 16 ;
-      alimb |= (mpi_limb_t)*p-- << 24 ;
-      alimb |= (mpi_limb_t)*p-- << 32 ;
-      alimb |= (mpi_limb_t)*p-- << 40 ;
-      alimb |= (mpi_limb_t)*p-- << 48 ;
-      alimb |= (mpi_limb_t)*p-- << 56 ;
-#else
-#       error please implement for this limb size.
-#endif
-      a->d[i++] = alimb;
-    }
-  if ( p >= buffer )
-    {
-#if BYTES_PER_MPI_LIMB == 4
-      alimb  = *p--;
-      if (p >= buffer)
-        alimb |= *p-- <<  8;
-      if (p >= buffer)
-        alimb |= *p-- << 16;
-      if (p >= buffer)
-        alimb |= *p-- << 24;
-#elif BYTES_PER_MPI_LIMB == 8
-      alimb  = (mpi_limb_t)*p--;
-      if (p >= buffer)
-        alimb |= (mpi_limb_t)*p-- << 8;
-      if (p >= buffer)
-        alimb |= (mpi_limb_t)*p-- << 16;
-      if (p >= buffer)
-        alimb |= (mpi_limb_t)*p-- << 24;
-      if (p >= buffer)
-        alimb |= (mpi_limb_t)*p-- << 32;
-      if (p >= buffer)
-        alimb |= (mpi_limb_t)*p-- << 40;
-      if (p >= buffer)
-        alimb |= (mpi_limb_t)*p-- << 48;
-      if (p >= buffer)
-        alimb |= (mpi_limb_t)*p-- << 56;
-#else
-#     error please implement for this limb size.
-#endif
-      a->d[i++] = alimb;
-    }
-  a->nlimbs = i;
-  gcry_assert (i == nlimbs);
-}
-
-
-/* Convert the external representation of an integer stored in BUFFER
-   with a length of BUFLEN into a newly create MPI returned in
-   RET_MPI.  If NBYTES is not NULL, it will receive the number of
-   bytes actually scanned after a successful operation.  */
-gcry_error_t
-gcry_mpi_scan (struct gcry_mpi **ret_mpi, enum gcry_mpi_format format,
-               const void *buffer_arg, size_t buflen, size_t *nscanned)
-{
-  const unsigned char *buffer = (const unsigned char*)buffer_arg;
-  struct gcry_mpi *a = NULL;
-  unsigned int len;
-  int secure = (buffer && gcry_is_secure (buffer));
-
-  if (format == GCRYMPI_FMT_SSH)
-    len = 0;
-  else
-    len = buflen;
-  
-  if (format == GCRYMPI_FMT_STD)
-    {
-      const unsigned char *s = buffer;
-
-      a = secure? mpi_alloc_secure ((len+BYTES_PER_MPI_LIMB-1)
-                                    /BYTES_PER_MPI_LIMB)
-                : mpi_alloc ((len+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);
-      if (len)
-        { 
-          a->sign = !!(*s & 0x80);
-          if (a->sign)
-            {
-              /* FIXME: we have to convert from 2compl to magnitude format */
-              mpi_free (a);
-              return gcry_error (GPG_ERR_INTERNAL);
-	    }
-          else
-            _gcry_mpi_set_buffer (a, s, len, 0);
-	}
-      if (ret_mpi)
-        {
-          mpi_normalize ( a );
-          *ret_mpi = a;
-	}
-      else
-        mpi_free(a);
-      return 0;
-    }
-  else if (format == GCRYMPI_FMT_USG)
-    {
-      a = secure? mpi_alloc_secure ((len+BYTES_PER_MPI_LIMB-1)
-                                    /BYTES_PER_MPI_LIMB)
-                : mpi_alloc ((len+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);
-
-      if (len)
-        _gcry_mpi_set_buffer (a, buffer, len, 0);
-      if (ret_mpi)
-        {
-          mpi_normalize ( a );
-          *ret_mpi = a;
-	}
-      else
-        mpi_free(a);
-      return 0;
-    }
-  else if (format == GCRYMPI_FMT_PGP)
-    {
-      a = mpi_read_from_buffer (buffer, &len, secure);
-      if (nscanned)
-        *nscanned = len;
-      if (ret_mpi && a)
-        {
-          mpi_normalize (a);
-          *ret_mpi = a;
-	}
-      else if (a)
-        {
-          mpi_free(a);
-          a = NULL;
-        }
-      return a? 0 : gcry_error (GPG_ERR_INV_OBJ);
-    }
-  else if (format == GCRYMPI_FMT_SSH)
-    {
-      const unsigned char *s = buffer;
-      size_t n;
-      
-      if (len && len < 4)
-        return gcry_error (GPG_ERR_TOO_SHORT);
-
-      n = (s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);
-      s += 4; 
-      if (len)
-        len -= 4;
-      if (len && n > len)
-        return gcry_error (GPG_ERR_TOO_LARGE);
-
-      a = secure? mpi_alloc_secure ((n+BYTES_PER_MPI_LIMB-1)
-                                    /BYTES_PER_MPI_LIMB)
-                : mpi_alloc ((n+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);
-      if (n)
-        {
-          a->sign = !!(*s & 0x80);
-          if (a->sign)
-            {
-              /* FIXME: we have to convert from 2compl to magnitude format */
-              mpi_free(a);
-              return gcry_error (GPG_ERR_INTERNAL);
-	    }
-          else
-            _gcry_mpi_set_buffer( a, s, n, 0 );
-	}
-      if (nscanned)
-        *nscanned = n+4;
-      if (ret_mpi)
-        {
-          mpi_normalize ( a );
-          *ret_mpi = a;
-        }
-      else
-        mpi_free(a);
-      return 0;
-    }
-  else if (format == GCRYMPI_FMT_HEX)
-    {
-      /* We can only handle C strings for now.  */
-      if (buflen)
-        return gcry_error (GPG_ERR_INV_ARG); 
-
-      a = secure? mpi_alloc_secure (0) : mpi_alloc(0);
-      if (mpi_fromstr (a, (const char *)buffer))
-        {
-          mpi_free (a);
-          return gcry_error (GPG_ERR_INV_OBJ);
-        }
-      if (ret_mpi) 
-        {
-          mpi_normalize ( a );
-          *ret_mpi = a;
-	}
-      else
-        mpi_free(a);
-      return 0;
-    }
-  else
-    return gcry_error (GPG_ERR_INV_ARG);
-}
-
-
-/* Convert the big integer A into the external representation
-   described by FORMAT and store it in the provided BUFFER which has
-   been allocated by the user with a size of BUFLEN bytes.  NWRITTEN
-   receives the actual length of the external representation unless it
-   has been passed as NULL.  BUFFER may be NULL to query the required
-   length.  */
-gcry_error_t
-gcry_mpi_print (enum gcry_mpi_format format,
-                unsigned char *buffer, size_t buflen,
-                size_t *nwritten, struct gcry_mpi *a)
-{
-  unsigned int nbits = mpi_get_nbits (a);
-  size_t len;
-  size_t dummy_nwritten;
-  
-  if (!nwritten)
-    nwritten = &dummy_nwritten;
-
-  len = buflen;
-  *nwritten = 0;
-  if (format == GCRYMPI_FMT_STD) 
-    {
-      unsigned char *tmp;
-      int extra = 0;
-      unsigned int n;
-      
-      if (a->sign)
-        return gcry_error (GPG_ERR_INTERNAL); /* Can't handle it yet. */
-
-      tmp = _gcry_mpi_get_buffer (a, &n, NULL);
-      if (!tmp)
-        return gpg_error_from_syserror ();
-      if (n && (*tmp & 0x80))
-        {
-          n++;
-          extra=1;
-	}
-      
-      if (buffer && n > len)
-        {
-          /* The provided buffer is too short. */
-          gcry_free (tmp);
-          return gcry_error (GPG_ERR_TOO_SHORT);  
-	}
-      if (buffer)
-        {
-          unsigned char *s = buffer;
-
-          if (extra)
-            *s++ = 0;
-          memcpy (s, tmp, n-extra);
-	}
-      gcry_free(tmp);
-      *nwritten = n;
-      return 0;
-    }
-  else if (format == GCRYMPI_FMT_USG)
-    {
-      unsigned int n = (nbits + 7)/8;
-
-      /* Note:  We ignore the sign for this format.  */
-      /* FIXME: for performance reasons we should put this into
-	 mpi_aprint because we can then use the buffer directly.  */
-      if (buffer && n > len)
-        return gcry_error (GPG_ERR_TOO_SHORT);
-      if (buffer)
-        {
-          unsigned char *tmp;
-
-          tmp = _gcry_mpi_get_buffer (a, &n, NULL);
-          if (!tmp)
-            return gpg_error_from_syserror ();
-          memcpy (buffer, tmp, n);
-          gcry_free (tmp);
-	}
-      *nwritten = n;
-      return 0;
-    }
-  else if (format == GCRYMPI_FMT_PGP)
-    {
-      unsigned int n = (nbits + 7)/8;
-      
-      /* The PGP format can only handle unsigned integers.  */
-      if( a->sign )
-        return gcry_error (GPG_ERR_INV_ARG); 
-
-      if (buffer && n+2 > len)
-        return gcry_error (GPG_ERR_TOO_SHORT);
-
-      if (buffer)
-        {
-          unsigned char *tmp;
-          unsigned char *s = buffer;
-
-          s[0] = nbits >> 8;
-          s[1] = nbits;
-          
-          tmp = _gcry_mpi_get_buffer (a, &n, NULL);
-          if (!tmp)
-            return gpg_error_from_syserror ();
-          memcpy (s+2, tmp, n);
-          gcry_free (tmp);
-	}
-      *nwritten = n+2;
-      return 0;
-    }
-  else if (format == GCRYMPI_FMT_SSH)
-    {
-      unsigned char *tmp;
-      int extra = 0;
-      unsigned int n;
-      
-      if (a->sign)
-        return gcry_error (GPG_ERR_INTERNAL); /* Can't handle it yet.  */
-      
-      tmp = _gcry_mpi_get_buffer (a, &n, NULL);
-      if (!tmp)
-        return gpg_error_from_syserror ();
-      if (n && (*tmp & 0x80))
-        {
-          n++;
-          extra=1;
-	}
-
-      if (buffer && n+4 > len)
-        {
-          gcry_free(tmp);
-          return gcry_error (GPG_ERR_TOO_SHORT);
-	}
-
-      if (buffer)
-        {
-          unsigned char *s = buffer;
-          
-          *s++ = n >> 24;
-          *s++ = n >> 16;
-          *s++ = n >> 8;
-          *s++ = n;
-          if (extra)
-            *s++ = 0;
-          
-          memcpy (s, tmp, n-extra);
-	}
-      gcry_free (tmp);
-      *nwritten = 4+n;
-      return 0;
-    }
-  else if (format == GCRYMPI_FMT_HEX)
-    {
-      unsigned char *tmp;
-      int i;
-      int extra = 0;
-      unsigned int n = 0;
-      
-      tmp = _gcry_mpi_get_buffer (a, &n, NULL);
-      if (!tmp)
-        return gpg_error_from_syserror ();
-      if (!n || (*tmp & 0x80))
-        extra = 2;
-
-      if (buffer && 2*n + extra + !!a->sign + 1 > len)
-        {
-          gcry_free(tmp);
-          return gcry_error (GPG_ERR_TOO_SHORT);
-	}
-      if (buffer)
-        {
-          unsigned char *s = buffer;
-
-          if (a->sign)
-            *s++ = '-';
-          if (extra)
-            {
-              *s++ = '0';
-              *s++ = '0';
-	    }
-          
-          for (i=0; i < n; i++)
-            {
-              unsigned int c = tmp[i];
-
-              *s++ = (c >> 4) < 10? '0'+(c>>4) : 'A'+(c>>4)-10 ;
-              c &= 15;
-              *s++ = c < 10? '0'+c : 'A'+c-10 ;
-	    }
-          *s++ = 0;
-          *nwritten = s - buffer;
-	}
-      else 
-        {
-          *nwritten = 2*n + extra + !!a->sign + 1;
-	}
-      gcry_free (tmp);
-      return 0;
-    }
-  else
-    return gcry_error (GPG_ERR_INV_ARG);
-}
-
-
-/*
- * Like gcry_mpi_print but this function allocates the buffer itself.
- * The caller has to supply the address of a pointer.  NWRITTEN may be
- * NULL.
- */
-gcry_error_t
-gcry_mpi_aprint (enum gcry_mpi_format format,
-                 unsigned char **buffer, size_t *nwritten,
-		 struct gcry_mpi *a)
-{
-  size_t n;
-  gcry_error_t rc;
-  
-  *buffer = NULL;
-  rc = gcry_mpi_print (format, NULL, 0, &n, a);
-  if (rc)
-    return rc;
-
-  *buffer = mpi_is_secure(a) ? gcry_malloc_secure (n) : gcry_malloc (n);
-  if (!*buffer)
-    return gpg_error_from_syserror ();
-  rc = gcry_mpi_print( format, *buffer, n, &n, a );
-  if (rc)
-    {
-      gcry_free(*buffer);
-      *buffer = NULL;
-    }
-  else if (nwritten)
-    *nwritten = n;
-  return rc;
-}
-
+/* mpicoder.c  -  Coder for the external representation of MPIs

+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003

+ *               2008 Free Software Foundation, Inc.

+ *

+ * This file is part of Libgcrypt.

+ *

+ * Libgcrypt is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU Lesser General Public License as

+ * published by the Free Software Foundation; either version 2.1 of

+ * the License, or (at your option) any later version.

+ *

+ * Libgcrypt is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.

+ */

+

+#include <config.h>

+#include <stdio.h>

+#include <string.h>

+#include <stdlib.h>

+

+#include "mpi-internal.h"

+#include "g10lib.h"

+

+#define MAX_EXTERN_MPI_BITS 16384

+

+/* Helper used to scan PGP style MPIs.  Returns NULL on failure. */

+static gcry_mpi_t

+mpi_read_from_buffer (const unsigned char *buffer, unsigned *ret_nread,

+                      int secure)

+{

+  int i, j;

+  unsigned int nbits, nbytes, nlimbs, nread=0;

+  mpi_limb_t a;

+  gcry_mpi_t val = MPI_NULL;

+  

+  if ( *ret_nread < 2 )

+    goto leave;

+  nbits = buffer[0] << 8 | buffer[1];

+  if ( nbits > MAX_EXTERN_MPI_BITS )

+    {

+/*       log_debug ("mpi too large (%u bits)\n", nbits); */

+      goto leave;

+    }

+  buffer += 2;

+  nread = 2;

+

+  nbytes = (nbits+7) / 8;

+  nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB;

+  val = secure? mpi_alloc_secure (nlimbs) : mpi_alloc (nlimbs);

+  i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;

+  i %= BYTES_PER_MPI_LIMB;

+  j= val->nlimbs = nlimbs;

+  val->sign = 0;

+  for ( ; j > 0; j-- )

+    {

+      a = 0;

+      for (; i < BYTES_PER_MPI_LIMB; i++ ) 

+        {

+          if ( ++nread > *ret_nread )

+            {

+/*               log_debug ("mpi larger than buffer"); */

+              mpi_free (val);

+              val = NULL;

+              goto leave;

+            }

+          a <<= 8;

+          a |= *buffer++;

+	}

+      i = 0;

+      val->d[j-1] = a;

+    }

+  

+ leave:

+  *ret_nread = nread;

+  return val;

+}

+

+

+/****************

+ * Fill the mpi VAL from the hex string in STR.

+ */

+static int

+mpi_fromstr (gcry_mpi_t val, const char *str)

+{

+  int sign = 0;

+  int prepend_zero = 0;

+  int i, j, c, c1, c2;

+  unsigned int nbits, nbytes, nlimbs;

+  mpi_limb_t a;

+

+  if ( *str == '-' )

+    {

+      sign = 1;

+      str++;

+    }

+

+  /* Skip optional hex prefix.  */

+  if ( *str == '0' && str[1] == 'x' )

+    str += 2;

+

+  nbits = 4 * strlen (str);

+  if ((nbits % 8))

+    prepend_zero = 1;

+

+  nbytes = (nbits+7) / 8;

+  nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB;

+

+  if ( val->alloced < nlimbs )

+    mpi_resize (val, nlimbs);

+

+  i = BYTES_PER_MPI_LIMB - (nbytes % BYTES_PER_MPI_LIMB);

+  i %= BYTES_PER_MPI_LIMB;

+  j = val->nlimbs = nlimbs;

+  val->sign = sign;

+  for (; j > 0; j--)

+    {

+      a = 0;

+      for (; i < BYTES_PER_MPI_LIMB; i++)

+        {

+          if (prepend_zero)

+            {

+              c1 = '0';

+              prepend_zero = 0;

+	    }

+          else

+            c1 = *str++;

+

+          if (!c1)

+            {

+              mpi_clear (val);

+              return 1;  /* Error.  */

+	    }

+          c2 = *str++;

+          if (!c2)

+            {

+              mpi_clear (val);

+              return 1;  /* Error.  */

+	    }

+          if ( c1 >= '0' && c1 <= '9' )

+            c = c1 - '0';

+          else if ( c1 >= 'a' && c1 <= 'f' )

+            c = c1 - 'a' + 10;

+          else if ( c1 >= 'A' && c1 <= 'F' )

+            c = c1 - 'A' + 10;

+          else

+            {

+              mpi_clear (val);

+              return 1;  /* Error.  */

+	    }

+          c <<= 4;

+          if ( c2 >= '0' && c2 <= '9' )

+            c |= c2 - '0';

+          else if( c2 >= 'a' && c2 <= 'f' )

+            c |= c2 - 'a' + 10;

+          else if( c2 >= 'A' && c2 <= 'F' )

+            c |= c2 - 'A' + 10;

+          else 

+            {

+              mpi_clear(val);

+              return 1;  /* Error. */

+	    }

+          a <<= 8;

+          a |= c;

+	}

+      i = 0;

+      val->d[j-1] = a;

+    }

+  

+  return 0;  /* Okay.  */

+}

+

+

+/* Dump the value of A in a format suitable for debugging to

+   Libgcrypt's logging stream.  Note that one leading space but no

+   trailing space or linefeed will be printed.  It is okay to pass

+   NULL for A. */

+void 

+gcry_mpi_dump (const gcry_mpi_t a)

+{

+  int i;

+

+  log_printf (" ");

+  if (!a)

+    log_printf ("[MPI_NULL]");

+  else 

+    {

+      if (a->sign)

+        log_printf ( "-");

+#if BYTES_PER_MPI_LIMB == 2

+# define X "4"

+#elif BYTES_PER_MPI_LIMB == 4

+# define X "8"

+#elif BYTES_PER_MPI_LIMB == 8

+# define X "16"

+#elif BYTES_PER_MPI_LIMB == 16

+# define X "32"

+#else

+# error please define the format here

+#endif

+      for (i=a->nlimbs; i > 0 ; i-- )

+        {

+          log_printf (i != a->nlimbs? "%0" X "lX":"%lX", (ulong)a->d[i-1]);

+        }

+#undef X

+      if (!a->nlimbs)

+        log_printf ("0");

+    }

+}

+

+/* Convience function used internally. */

+void

+_gcry_log_mpidump (const char *text, gcry_mpi_t a)

+{

+  log_printf ("%s:", text);

+  gcry_mpi_dump (a);

+  log_printf ("\n");

+}

+

+

+/* Return an allocated buffer with the MPI (msb first).  NBYTES

+   receives the length of this buffer.  Caller must free the return

+   string.  This function returns an allocated buffer with NBYTES set

+   to zero if the value of A is zero.  If sign is not NULL, it will be

+   set to the sign of the A.  On error NULL is returned and ERRNO set

+   appropriately.  */

+static unsigned char *

+do_get_buffer (gcry_mpi_t a, unsigned int *nbytes, int *sign, int force_secure)

+{

+  unsigned char *p, *buffer;

+  mpi_limb_t alimb;

+  int i;

+  size_t n;

+  

+  if (sign)

+    *sign = a->sign;

+

+  *nbytes = a->nlimbs * BYTES_PER_MPI_LIMB;

+  n = *nbytes? *nbytes:1; /* Allocate at least one byte.  */

+  p = buffer = (force_secure || mpi_is_secure(a))? gcry_malloc_secure (n)

+						 : gcry_malloc (n);

+  if (!buffer)

+    return NULL;

+

+  for (i=a->nlimbs-1; i >= 0; i--)

+    {

+      alimb = a->d[i];

+#if BYTES_PER_MPI_LIMB == 4

+      *p++ = alimb >> 24;

+      *p++ = alimb >> 16;

+      *p++ = alimb >>  8;

+      *p++ = alimb	  ;

+#elif BYTES_PER_MPI_LIMB == 8

+      *p++ = alimb >> 56;

+      *p++ = alimb >> 48;

+      *p++ = alimb >> 40;

+      *p++ = alimb >> 32;

+      *p++ = alimb >> 24;

+      *p++ = alimb >> 16;

+      *p++ = alimb >>  8;

+      *p++ = alimb	  ;

+#else

+#     error please implement for this limb size.

+#endif

+    }

+

+  /* This is sub-optimal but we need to do the shift operation because

+     the caller has to free the returned buffer.  */

+  for (p=buffer; !*p && *nbytes; p++, --*nbytes)

+    ;

+  if (p != buffer)

+    memmove (buffer,p, *nbytes);

+  return buffer;

+}

+

+

+byte *

+_gcry_mpi_get_buffer (gcry_mpi_t a, unsigned int *nbytes, int *sign)

+{

+  return do_get_buffer (a, nbytes, sign, 0);

+}

+

+byte *

+_gcry_mpi_get_secure_buffer (gcry_mpi_t a, unsigned *nbytes, int *sign)

+{

+  return do_get_buffer (a, nbytes, sign, 1);

+}

+

+

+/*

+ * Use the NBYTES at BUFFER_ARG to update A.  Set the sign of a to

+ * SIGN.

+ */

+void

+_gcry_mpi_set_buffer (gcry_mpi_t a, const void *buffer_arg,

+                      unsigned int nbytes, int sign)

+{

+  const unsigned char *buffer = (const unsigned char*)buffer_arg;

+  const unsigned char *p;

+  mpi_limb_t alimb;

+  int nlimbs;

+  int i;

+  

+  nlimbs = (nbytes + BYTES_PER_MPI_LIMB - 1) / BYTES_PER_MPI_LIMB;

+  RESIZE_IF_NEEDED(a, nlimbs);

+  a->sign = sign;

+  

+  for (i=0, p = buffer+nbytes-1; p >= buffer+BYTES_PER_MPI_LIMB; ) 

+    {

+#if BYTES_PER_MPI_LIMB == 4

+      alimb  = *p--	    ;

+      alimb |= *p-- <<  8 ;

+      alimb |= *p-- << 16 ;

+      alimb |= *p-- << 24 ;

+#elif BYTES_PER_MPI_LIMB == 8

+      alimb  = (mpi_limb_t)*p--	;

+      alimb |= (mpi_limb_t)*p-- <<  8 ;

+      alimb |= (mpi_limb_t)*p-- << 16 ;

+      alimb |= (mpi_limb_t)*p-- << 24 ;

+      alimb |= (mpi_limb_t)*p-- << 32 ;

+      alimb |= (mpi_limb_t)*p-- << 40 ;

+      alimb |= (mpi_limb_t)*p-- << 48 ;

+      alimb |= (mpi_limb_t)*p-- << 56 ;

+#else

+#       error please implement for this limb size.

+#endif

+      a->d[i++] = alimb;

+    }

+  if ( p >= buffer )

+    {

+#if BYTES_PER_MPI_LIMB == 4

+      alimb  = *p--;

+      if (p >= buffer)

+        alimb |= *p-- <<  8;

+      if (p >= buffer)

+        alimb |= *p-- << 16;

+      if (p >= buffer)

+        alimb |= *p-- << 24;

+#elif BYTES_PER_MPI_LIMB == 8

+      alimb  = (mpi_limb_t)*p--;

+      if (p >= buffer)

+        alimb |= (mpi_limb_t)*p-- << 8;

+      if (p >= buffer)

+        alimb |= (mpi_limb_t)*p-- << 16;

+      if (p >= buffer)

+        alimb |= (mpi_limb_t)*p-- << 24;

+      if (p >= buffer)

+        alimb |= (mpi_limb_t)*p-- << 32;

+      if (p >= buffer)

+        alimb |= (mpi_limb_t)*p-- << 40;

+      if (p >= buffer)

+        alimb |= (mpi_limb_t)*p-- << 48;

+      if (p >= buffer)

+        alimb |= (mpi_limb_t)*p-- << 56;

+#else

+#     error please implement for this limb size.

+#endif

+      a->d[i++] = alimb;

+    }

+  a->nlimbs = i;

+  gcry_assert (i == nlimbs);

+}

+

+

+/* Convert the external representation of an integer stored in BUFFER

+   with a length of BUFLEN into a newly create MPI returned in

+   RET_MPI.  If NBYTES is not NULL, it will receive the number of

+   bytes actually scanned after a successful operation.  */

+gcry_error_t

+gcry_mpi_scan (struct gcry_mpi **ret_mpi, enum gcry_mpi_format format,

+               const void *buffer_arg, size_t buflen, size_t *nscanned)

+{

+  const unsigned char *buffer = (const unsigned char*)buffer_arg;

+  struct gcry_mpi *a = NULL;

+  unsigned int len;

+  int secure = (buffer && gcry_is_secure (buffer));

+

+  if (format == GCRYMPI_FMT_SSH)

+    len = 0;

+  else

+    len = buflen;

+  

+  if (format == GCRYMPI_FMT_STD)

+    {

+      const unsigned char *s = buffer;

+

+      a = secure? mpi_alloc_secure ((len+BYTES_PER_MPI_LIMB-1)

+                                    /BYTES_PER_MPI_LIMB)

+                : mpi_alloc ((len+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);

+      if (len)

+        { 

+          a->sign = !!(*s & 0x80);

+          if (a->sign)

+            {

+              /* FIXME: we have to convert from 2compl to magnitude format */

+              mpi_free (a);

+              return gcry_error (GPG_ERR_INTERNAL);

+	    }

+          else

+            _gcry_mpi_set_buffer (a, s, len, 0);

+	}

+      if (ret_mpi)

+        {

+          mpi_normalize ( a );

+          *ret_mpi = a;

+	}

+      else

+        mpi_free(a);

+      return 0;

+    }

+  else if (format == GCRYMPI_FMT_USG)

+    {

+      a = secure? mpi_alloc_secure ((len+BYTES_PER_MPI_LIMB-1)

+                                    /BYTES_PER_MPI_LIMB)

+                : mpi_alloc ((len+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);

+

+      if (len)

+        _gcry_mpi_set_buffer (a, buffer, len, 0);

+      if (ret_mpi)

+        {

+          mpi_normalize ( a );

+          *ret_mpi = a;

+	}

+      else

+        mpi_free(a);

+      return 0;

+    }

+  else if (format == GCRYMPI_FMT_PGP)

+    {

+      a = mpi_read_from_buffer (buffer, &len, secure);

+      if (nscanned)

+        *nscanned = len;

+      if (ret_mpi && a)

+        {

+          mpi_normalize (a);

+          *ret_mpi = a;

+	}

+      else if (a)

+        {

+          mpi_free(a);

+          a = NULL;

+        }

+      return a? 0 : gcry_error (GPG_ERR_INV_OBJ);

+    }

+  else if (format == GCRYMPI_FMT_SSH)

+    {

+      const unsigned char *s = buffer;

+      size_t n;

+      

+      /* This test is not strictly necessary and an assert (!len)

+         would be sufficient.  We keep this test in case we later

+         allow the BUFLEN argument to act as a sanitiy check.  Same

+         below. */

+      if (len && len < 4)

+        return gcry_error (GPG_ERR_TOO_SHORT);

+

+      n = (s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);

+      s += 4; 

+      if (len)

+        len -= 4;

+      if (len && n > len)

+        return gcry_error (GPG_ERR_TOO_LARGE);

+

+      a = secure? mpi_alloc_secure ((n+BYTES_PER_MPI_LIMB-1)

+                                    /BYTES_PER_MPI_LIMB)

+                : mpi_alloc ((n+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);

+      if (n)

+        {

+          a->sign = !!(*s & 0x80);

+          if (a->sign)

+            {

+              /* FIXME: we have to convert from 2compl to magnitude format */

+              mpi_free(a);

+              return gcry_error (GPG_ERR_INTERNAL);

+	    }

+          else

+            _gcry_mpi_set_buffer( a, s, n, 0 );

+	}

+      if (nscanned)

+        *nscanned = n+4;

+      if (ret_mpi)

+        {

+          mpi_normalize ( a );

+          *ret_mpi = a;

+        }

+      else

+        mpi_free(a);

+      return 0;

+    }

+  else if (format == GCRYMPI_FMT_HEX)

+    {

+      /* We can only handle C strings for now.  */

+      if (buflen)

+        return gcry_error (GPG_ERR_INV_ARG); 

+

+      a = secure? mpi_alloc_secure (0) : mpi_alloc(0);

+      if (mpi_fromstr (a, (const char *)buffer))

+        {

+          mpi_free (a);

+          return gcry_error (GPG_ERR_INV_OBJ);

+        }

+      if (ret_mpi) 

+        {

+          mpi_normalize ( a );

+          *ret_mpi = a;

+	}

+      else

+        mpi_free(a);

+      return 0;

+    }

+  else

+    return gcry_error (GPG_ERR_INV_ARG);

+}

+

+

+/* Convert the big integer A into the external representation

+   described by FORMAT and store it in the provided BUFFER which has

+   been allocated by the user with a size of BUFLEN bytes.  NWRITTEN

+   receives the actual length of the external representation unless it

+   has been passed as NULL.  BUFFER may be NULL to query the required

+   length.  */

+gcry_error_t

+gcry_mpi_print (enum gcry_mpi_format format,

+                unsigned char *buffer, size_t buflen,

+                size_t *nwritten, struct gcry_mpi *a)

+{

+  unsigned int nbits = mpi_get_nbits (a);

+  size_t len;

+  size_t dummy_nwritten;

+  

+  if (!nwritten)

+    nwritten = &dummy_nwritten;

+

+  len = buflen;

+  *nwritten = 0;

+  if (format == GCRYMPI_FMT_STD) 

+    {

+      unsigned char *tmp;

+      int extra = 0;

+      unsigned int n;

+      

+      if (a->sign)

+        return gcry_error (GPG_ERR_INTERNAL); /* Can't handle it yet. */

+

+      tmp = _gcry_mpi_get_buffer (a, &n, NULL);

+      if (!tmp)

+        return gpg_error_from_syserror ();

+      if (n && (*tmp & 0x80))

+        {

+          n++;

+          extra=1;

+	}

+      

+      if (buffer && n > len)

+        {

+          /* The provided buffer is too short. */

+          gcry_free (tmp);

+          return gcry_error (GPG_ERR_TOO_SHORT);  

+	}

+      if (buffer)

+        {

+          unsigned char *s = buffer;

+

+          if (extra)

+            *s++ = 0;

+          memcpy (s, tmp, n-extra);

+	}

+      gcry_free(tmp);

+      *nwritten = n;

+      return 0;

+    }

+  else if (format == GCRYMPI_FMT_USG)

+    {

+      unsigned int n = (nbits + 7)/8;

+

+      /* Note:  We ignore the sign for this format.  */

+      /* FIXME: for performance reasons we should put this into

+	 mpi_aprint because we can then use the buffer directly.  */

+      if (buffer && n > len)

+        return gcry_error (GPG_ERR_TOO_SHORT);

+      if (buffer)

+        {

+          unsigned char *tmp;

+

+          tmp = _gcry_mpi_get_buffer (a, &n, NULL);

+          if (!tmp)

+            return gpg_error_from_syserror ();

+          memcpy (buffer, tmp, n);

+          gcry_free (tmp);

+	}

+      *nwritten = n;

+      return 0;

+    }

+  else if (format == GCRYMPI_FMT_PGP)

+    {

+      unsigned int n = (nbits + 7)/8;

+      

+      /* The PGP format can only handle unsigned integers.  */

+      if( a->sign )

+        return gcry_error (GPG_ERR_INV_ARG); 

+

+      if (buffer && n+2 > len)

+        return gcry_error (GPG_ERR_TOO_SHORT);

+

+      if (buffer)

+        {

+          unsigned char *tmp;

+          unsigned char *s = buffer;

+

+          s[0] = nbits >> 8;

+          s[1] = nbits;

+          

+          tmp = _gcry_mpi_get_buffer (a, &n, NULL);

+          if (!tmp)

+            return gpg_error_from_syserror ();

+          memcpy (s+2, tmp, n);

+          gcry_free (tmp);

+	}

+      *nwritten = n+2;

+      return 0;

+    }

+  else if (format == GCRYMPI_FMT_SSH)

+    {

+      unsigned char *tmp;

+      int extra = 0;

+      unsigned int n;

+      

+      if (a->sign)

+        return gcry_error (GPG_ERR_INTERNAL); /* Can't handle it yet.  */

+      

+      tmp = _gcry_mpi_get_buffer (a, &n, NULL);

+      if (!tmp)

+        return gpg_error_from_syserror ();

+      if (n && (*tmp & 0x80))

+        {

+          n++;

+          extra=1;

+	}

+

+      if (buffer && n+4 > len)

+        {

+          gcry_free(tmp);

+          return gcry_error (GPG_ERR_TOO_SHORT);

+	}

+

+      if (buffer)

+        {

+          unsigned char *s = buffer;

+          

+          *s++ = n >> 24;

+          *s++ = n >> 16;

+          *s++ = n >> 8;

+          *s++ = n;

+          if (extra)

+            *s++ = 0;

+          

+          memcpy (s, tmp, n-extra);

+	}

+      gcry_free (tmp);

+      *nwritten = 4+n;

+      return 0;

+    }

+  else if (format == GCRYMPI_FMT_HEX)

+    {

+      unsigned char *tmp;

+      int i;

+      int extra = 0;

+      unsigned int n = 0;

+      

+      tmp = _gcry_mpi_get_buffer (a, &n, NULL);

+      if (!tmp)

+        return gpg_error_from_syserror ();

+      if (!n || (*tmp & 0x80))

+        extra = 2;

+

+      if (buffer && 2*n + extra + !!a->sign + 1 > len)

+        {

+          gcry_free(tmp);

+          return gcry_error (GPG_ERR_TOO_SHORT);

+	}

+      if (buffer)

+        {

+          unsigned char *s = buffer;

+

+          if (a->sign)

+            *s++ = '-';

+          if (extra)

+            {

+              *s++ = '0';

+              *s++ = '0';

+	    }

+          

+          for (i=0; i < n; i++)

+            {

+              unsigned int c = tmp[i];

+

+              *s++ = (c >> 4) < 10? '0'+(c>>4) : 'A'+(c>>4)-10 ;

+              c &= 15;

+              *s++ = c < 10? '0'+c : 'A'+c-10 ;

+	    }

+          *s++ = 0;

+          *nwritten = s - buffer;

+	}

+      else 

+        {

+          *nwritten = 2*n + extra + !!a->sign + 1;

+	}

+      gcry_free (tmp);

+      return 0;

+    }

+  else

+    return gcry_error (GPG_ERR_INV_ARG);

+}

+

+

+/*

+ * Like gcry_mpi_print but this function allocates the buffer itself.

+ * The caller has to supply the address of a pointer.  NWRITTEN may be

+ * NULL.

+ */

+gcry_error_t

+gcry_mpi_aprint (enum gcry_mpi_format format,

+                 unsigned char **buffer, size_t *nwritten,

+		 struct gcry_mpi *a)

+{

+  size_t n;

+  gcry_error_t rc;

+  

+  *buffer = NULL;

+  rc = gcry_mpi_print (format, NULL, 0, &n, a);

+  if (rc)

+    return rc;

+

+  *buffer = mpi_is_secure(a) ? gcry_malloc_secure (n) : gcry_malloc (n);

+  if (!*buffer)

+    return gpg_error_from_syserror ();

+  rc = gcry_mpi_print( format, *buffer, n, &n, a );

+  if (rc)

+    {

+      gcry_free(*buffer);

+      *buffer = NULL;

+    }

+  else if (nwritten)

+    *nwritten = n;

+  return rc;

+}

+

diff --git a/libgcrypt-1.4.6/mpi/mpiutil.c b/libgcrypt-1.4.6/mpi/mpiutil.c
index 4dc5211..f406cbc 100644
--- a/libgcrypt-1.4.6/mpi/mpiutil.c
+++ b/libgcrypt-1.4.6/mpi/mpiutil.c
@@ -1,462 +1,461 @@
-/* mpiutil.ac  -  Utility functions for MPI
- * Copyright (C) 1998, 2000, 2001, 2002, 2003,
- *               2007  Free Software Foundation, Inc.
- *
- * This file is part of Libgcrypt.
- *
- * Libgcrypt is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * Libgcrypt is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <config.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "g10lib.h"
-#include "mpi-internal.h"
-#include "memory.h"
-#include "mod-source-info.h"
-
-
-const char *
-_gcry_mpi_get_hw_config (void)
-{
-  return mod_source_info + 1;
-}
-
-
-/****************
- * Note:  It was a bad idea to use the number of limbs to allocate
- *	  because on a alpha the limbs are large but we normally need
- *	  integers of n bits - So we should change this to bits (or bytes).
- *
- *	  But mpi_alloc is used in a lot of places :-(.  New code
- *	  should use mpi_new.
- */
-gcry_mpi_t
-_gcry_mpi_alloc( unsigned nlimbs )
-{
-    gcry_mpi_t a;
-
-    a = gcry_xmalloc( sizeof *a );
-    a->d = nlimbs? mpi_alloc_limb_space( nlimbs, 0 ) : NULL;
-    a->alloced = nlimbs;
-    a->nlimbs = 0;
-    a->sign = 0;
-    a->flags = 0;
-    return a;
-}
-
-void
-_gcry_mpi_m_check( gcry_mpi_t a )
-{
-    _gcry_check_heap(a);
-    _gcry_check_heap(a->d);
-}
-
-gcry_mpi_t
-_gcry_mpi_alloc_secure( unsigned nlimbs )
-{
-    gcry_mpi_t a;
-
-    a = gcry_xmalloc( sizeof *a );
-    a->d = nlimbs? mpi_alloc_limb_space( nlimbs, 1 ) : NULL;
-    a->alloced = nlimbs;
-    a->flags = 1;
-    a->nlimbs = 0;
-    a->sign = 0;
-    return a;
-}
-
-
-
-mpi_ptr_t
-_gcry_mpi_alloc_limb_space( unsigned int nlimbs, int secure )
-{
-    mpi_ptr_t p;
-    size_t len;
-
-    len = (nlimbs ? nlimbs : 1) * sizeof (mpi_limb_t);
-    p = secure ? gcry_xmalloc_secure (len) : gcry_xmalloc (len);
-    if (! nlimbs)
-      *p = 0;
-
-    return p;
-}
-
-void
-_gcry_mpi_free_limb_space( mpi_ptr_t a, unsigned int nlimbs)
-{
-  if (a)
-    {
-      size_t len = nlimbs * sizeof(mpi_limb_t);
-      
-      /* If we have information on the number of allocated limbs, we
-         better wipe that space out.  This is a failsafe feature if
-         secure memory has been disabled or was not properly
-         implemented in user provided allocation functions. */
-      if (len)
-        wipememory (a, len);
-      gcry_free(a);
-    }
-}
-
-
-void
-_gcry_mpi_assign_limb_space( gcry_mpi_t a, mpi_ptr_t ap, unsigned int nlimbs )
-{
-  _gcry_mpi_free_limb_space (a->d, a->alloced);
-  a->d = ap;
-  a->alloced = nlimbs;
-}
-
-
-
-/****************
- * Resize the array of A to NLIMBS. The additional space is cleared
- * (set to 0).
- */
-void
-_gcry_mpi_resize (gcry_mpi_t a, unsigned nlimbs)
-{
-  size_t i;
-
-  if (nlimbs <= a->alloced)
-    {
-      /* We only need to clear the new space (this is a nop if the
-         limb space is already of the correct size. */
-      for (i=a->nlimbs; i < a->alloced; i++)
-        a->d[i] = 0;
-      return; 
-    }
-
-  /* Actually resize the limb space.  */
-  if (a->d)
-    {
-      a->d = gcry_xrealloc (a->d, nlimbs * sizeof (mpi_limb_t));
-      for (i=a->alloced; i < nlimbs; i++)
-        a->d[i] = 0;
-    }
-  else
-    {
-      if (a->flags & 1)
-	/* Secure memory is wanted.  */
-	a->d = gcry_xcalloc_secure (nlimbs , sizeof (mpi_limb_t));
-      else
-	/* Standard memory.  */
-	a->d = gcry_xcalloc (nlimbs , sizeof (mpi_limb_t));
-    }
-  a->alloced = nlimbs;
-}
-
-void
-_gcry_mpi_clear( gcry_mpi_t a )
-{
-    a->nlimbs = 0;
-    a->flags = 0;
-}
-
-
-void
-_gcry_mpi_free( gcry_mpi_t a )
-{
-  if (!a )
-    return;
-  if ((a->flags & 4))
-    gcry_free( a->d );
-  else
-    {
-      _gcry_mpi_free_limb_space(a->d, a->alloced);
-    }
-  if ((a->flags & ~7))
-    log_bug("invalid flag value in mpi\n");
-  gcry_free(a);
-}
-
-static void
-mpi_set_secure( gcry_mpi_t a )
-{
-  mpi_ptr_t ap, bp;
-
-  if ( (a->flags & 1) )
-    return;
-  a->flags |= 1;
-  ap = a->d;
-  if (!a->nlimbs)
-    {
-      gcry_assert (!ap);
-      return;
-    }
-  bp = mpi_alloc_limb_space (a->nlimbs, 1);
-  MPN_COPY( bp, ap, a->nlimbs );
-  a->d = bp;
-  _gcry_mpi_free_limb_space (ap, a->alloced);
-}
-
-
-gcry_mpi_t
-gcry_mpi_set_opaque( gcry_mpi_t a, void *p, unsigned int nbits )
-{
-  if (!a) 
-    a = mpi_alloc(0);
-    
-  if( a->flags & 4 )
-    gcry_free( a->d );
-  else 
-    _gcry_mpi_free_limb_space (a->d, a->alloced);
-
-  a->d = p;
-  a->alloced = 0;
-  a->nlimbs = 0;
-  a->sign  = nbits;
-  a->flags = 4;
-  return a;
-}
-
-
-void *
-gcry_mpi_get_opaque( gcry_mpi_t a, unsigned int *nbits )
-{
-    if( !(a->flags & 4) )
-	log_bug("mpi_get_opaque on normal mpi\n");
-    if( nbits )
-	*nbits = a->sign;
-    return a->d;
-}
-
-
-/****************
- * Note: This copy function should not interpret the MPI
- *	 but copy it transparently.
- */
-gcry_mpi_t
-gcry_mpi_copy( gcry_mpi_t a )
-{
-    int i;
-    gcry_mpi_t b;
-
-    if( a && (a->flags & 4) ) {
-	void *p = gcry_is_secure(a->d)? gcry_xmalloc_secure( (a->sign+7)/8 )
-				     : gcry_xmalloc( (a->sign+7)/8 );
-	memcpy( p, a->d, (a->sign+7)/8 );
-	b = gcry_mpi_set_opaque( NULL, p, a->sign );
-    }
-    else if( a ) {
-	b = mpi_is_secure(a)? mpi_alloc_secure( a->nlimbs )
-			    : mpi_alloc( a->nlimbs );
-	b->nlimbs = a->nlimbs;
-	b->sign = a->sign;
-	b->flags  = a->flags;
-	for(i=0; i < b->nlimbs; i++ )
-	    b->d[i] = a->d[i];
-    }
-    else
-	b = NULL;
-    return b;
-}
-
-
-/****************
- * This function allocates an MPI which is optimized to hold
- * a value as large as the one given in the argument and allocates it
- * with the same flags as A.
- */
-gcry_mpi_t
-_gcry_mpi_alloc_like( gcry_mpi_t a )
-{
-    gcry_mpi_t b;
-
-    if( a && (a->flags & 4) ) {
-	int n = (a->sign+7)/8;
-	void *p = gcry_is_secure(a->d)? gcry_malloc_secure( n )
-				     : gcry_malloc( n );
-	memcpy( p, a->d, n );
-	b = gcry_mpi_set_opaque( NULL, p, a->sign );
-    }
-    else if( a ) {
-	b = mpi_is_secure(a)? mpi_alloc_secure( a->nlimbs )
-			    : mpi_alloc( a->nlimbs );
-	b->nlimbs = 0;
-	b->sign = 0;
-	b->flags = a->flags;
-    }
-    else
-	b = NULL;
-    return b;
-}
-
-
-gcry_mpi_t
-gcry_mpi_set( gcry_mpi_t w, gcry_mpi_t u)
-{
-  mpi_ptr_t wp, up;
-  mpi_size_t usize = u->nlimbs;
-  int usign = u->sign;
-  
-  if (!w)
-    w = _gcry_mpi_alloc( mpi_get_nlimbs(u) );
-  RESIZE_IF_NEEDED(w, usize);
-  wp = w->d;
-  up = u->d;
-  MPN_COPY( wp, up, usize );
-  w->nlimbs = usize;
-  w->flags = u->flags;
-  w->sign = usign;
-  return w;
-}
-
-
-gcry_mpi_t
-gcry_mpi_set_ui( gcry_mpi_t w, unsigned long u)
-{
-  if (!w)
-    w = _gcry_mpi_alloc (1);
-  /* FIXME: If U is 0 we have no need to resize and thus possible
-     allocating the the limbs. */
-  RESIZE_IF_NEEDED(w, 1);
-  w->d[0] = u;
-  w->nlimbs = u? 1:0;
-  w->sign = 0;
-  w->flags = 0;
-  return w;
-}
-
-gcry_err_code_t
-_gcry_mpi_get_ui (gcry_mpi_t w, unsigned long *u)
-{
-  gcry_err_code_t err = GPG_ERR_NO_ERROR;
-  unsigned long x = 0;
-
-  if (w->nlimbs > 1)
-    err = GPG_ERR_TOO_LARGE;
-  else if (w->nlimbs == 1)
-    x = w->d[0];
-  else
-    x = 0;
-
-  if (! err)
-    *u = x;
-  
-  return err;
-}
-
-gcry_error_t
-gcry_mpi_get_ui (gcry_mpi_t w, unsigned long *u)
-{
-  gcry_err_code_t err = GPG_ERR_NO_ERROR;
-
-  err = _gcry_mpi_get_ui (w, u);
-  
-  return gcry_error (err);
-}
-
-gcry_mpi_t
-_gcry_mpi_alloc_set_ui( unsigned long u)
-{
-    gcry_mpi_t w = mpi_alloc(1);
-    w->d[0] = u;
-    w->nlimbs = u? 1:0;
-    w->sign = 0;
-    return w;
-}
-
-void
-gcry_mpi_swap( gcry_mpi_t a, gcry_mpi_t b)
-{
-    struct gcry_mpi tmp;
-
-    tmp = *a; *a = *b; *b = tmp;
-}
-
-
-gcry_mpi_t
-gcry_mpi_new( unsigned int nbits )
-{
-    return _gcry_mpi_alloc ( (nbits+BITS_PER_MPI_LIMB-1)
-                             / BITS_PER_MPI_LIMB );
-}
-
-
-gcry_mpi_t
-gcry_mpi_snew( unsigned int nbits )
-{
-  return _gcry_mpi_alloc_secure ( (nbits+BITS_PER_MPI_LIMB-1)
-                                  / BITS_PER_MPI_LIMB );
-}
-
-void
-gcry_mpi_release( gcry_mpi_t a )
-{
-    _gcry_mpi_free( a );
-}
-
-void
-gcry_mpi_randomize( gcry_mpi_t w,
-		    unsigned int nbits, enum gcry_random_level level )
-{
-  unsigned char *p;
-  size_t nbytes = (nbits+7)/8;
-  
-  if (level == GCRY_WEAK_RANDOM)
-    {
-      p = mpi_is_secure(w) ? gcry_xmalloc_secure (nbytes)
-                           : gcry_xmalloc (nbytes);
-      gcry_create_nonce (p, nbytes);
-    }
-  else
-    {
-      p = mpi_is_secure(w) ? gcry_random_bytes_secure (nbytes, level)
-                           : gcry_random_bytes (nbytes, level);
-    }
-  _gcry_mpi_set_buffer( w, p, nbytes, 0 );
-  gcry_free (p);
-}
-
-
-void
-gcry_mpi_set_flag( gcry_mpi_t a, enum gcry_mpi_flag flag )
-{
-    switch( flag ) {
-      case GCRYMPI_FLAG_SECURE:  mpi_set_secure(a); break;
-      case GCRYMPI_FLAG_OPAQUE:
-      default: log_bug("invalid flag value\n");
-    }
-}
-
-void
-gcry_mpi_clear_flag( gcry_mpi_t a, enum gcry_mpi_flag flag )
-{
-  (void)a; /* Not yet used. */
-
-  switch (flag)
-    {
-    case GCRYMPI_FLAG_SECURE:
-    case GCRYMPI_FLAG_OPAQUE:
-    default: log_bug("invalid flag value\n");
-    }
-}
-
-int
-gcry_mpi_get_flag( gcry_mpi_t a, enum gcry_mpi_flag flag )
-{
-  switch (flag)
-    {
-    case GCRYMPI_FLAG_SECURE: return (a->flags & 1);
-    case GCRYMPI_FLAG_OPAQUE: return (a->flags & 4);
-    default: log_bug("invalid flag value\n");
-    }
-  /*NOTREACHED*/
-  return 0;
-}
-
+/* mpiutil.ac  -  Utility functions for MPI

+ * Copyright (C) 1998, 2000, 2001, 2002, 2003,

+ *               2007  Free Software Foundation, Inc.

+ *

+ * This file is part of Libgcrypt.

+ *

+ * Libgcrypt is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU Lesser General Public License as

+ * published by the Free Software Foundation; either version 2.1 of

+ * the License, or (at your option) any later version.

+ *

+ * Libgcrypt is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.

+ */

+

+#include <config.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include "g10lib.h"

+#include "mpi-internal.h"

+#include "mod-source-info.h"

+

+

+const char *

+_gcry_mpi_get_hw_config (void)

+{

+  return mod_source_info + 1;

+}

+

+

+/****************

+ * Note:  It was a bad idea to use the number of limbs to allocate

+ *	  because on a alpha the limbs are large but we normally need

+ *	  integers of n bits - So we should change this to bits (or bytes).

+ *

+ *	  But mpi_alloc is used in a lot of places :-(.  New code

+ *	  should use mpi_new.

+ */

+gcry_mpi_t

+_gcry_mpi_alloc( unsigned nlimbs )

+{

+    gcry_mpi_t a;

+

+    a = gcry_xmalloc( sizeof *a );

+    a->d = nlimbs? mpi_alloc_limb_space( nlimbs, 0 ) : NULL;

+    a->alloced = nlimbs;

+    a->nlimbs = 0;

+    a->sign = 0;

+    a->flags = 0;

+    return a;

+}

+

+void

+_gcry_mpi_m_check( gcry_mpi_t a )

+{

+    _gcry_check_heap(a);

+    _gcry_check_heap(a->d);

+}

+

+gcry_mpi_t

+_gcry_mpi_alloc_secure( unsigned nlimbs )

+{

+    gcry_mpi_t a;

+

+    a = gcry_xmalloc( sizeof *a );

+    a->d = nlimbs? mpi_alloc_limb_space( nlimbs, 1 ) : NULL;

+    a->alloced = nlimbs;

+    a->flags = 1;

+    a->nlimbs = 0;

+    a->sign = 0;

+    return a;

+}

+

+

+

+mpi_ptr_t

+_gcry_mpi_alloc_limb_space( unsigned int nlimbs, int secure )

+{

+    mpi_ptr_t p;

+    size_t len;

+

+    len = (nlimbs ? nlimbs : 1) * sizeof (mpi_limb_t);

+    p = secure ? gcry_xmalloc_secure (len) : gcry_xmalloc (len);

+    if (! nlimbs)

+      *p = 0;

+

+    return p;

+}

+

+void

+_gcry_mpi_free_limb_space( mpi_ptr_t a, unsigned int nlimbs)

+{

+  if (a)

+    {

+      size_t len = nlimbs * sizeof(mpi_limb_t);

+      

+      /* If we have information on the number of allocated limbs, we

+         better wipe that space out.  This is a failsafe feature if

+         secure memory has been disabled or was not properly

+         implemented in user provided allocation functions. */

+      if (len)

+        wipememory (a, len);

+      gcry_free(a);

+    }

+}

+

+

+void

+_gcry_mpi_assign_limb_space( gcry_mpi_t a, mpi_ptr_t ap, unsigned int nlimbs )

+{

+  _gcry_mpi_free_limb_space (a->d, a->alloced);

+  a->d = ap;

+  a->alloced = nlimbs;

+}

+

+

+

+/****************

+ * Resize the array of A to NLIMBS. The additional space is cleared

+ * (set to 0).

+ */

+void

+_gcry_mpi_resize (gcry_mpi_t a, unsigned nlimbs)

+{

+  size_t i;

+

+  if (nlimbs <= a->alloced)

+    {

+      /* We only need to clear the new space (this is a nop if the

+         limb space is already of the correct size. */

+      for (i=a->nlimbs; i < a->alloced; i++)

+        a->d[i] = 0;

+      return; 

+    }

+

+  /* Actually resize the limb space.  */

+  if (a->d)

+    {

+      a->d = gcry_xrealloc (a->d, nlimbs * sizeof (mpi_limb_t));

+      for (i=a->alloced; i < nlimbs; i++)

+        a->d[i] = 0;

+    }

+  else

+    {

+      if (a->flags & 1)

+	/* Secure memory is wanted.  */

+	a->d = gcry_xcalloc_secure (nlimbs , sizeof (mpi_limb_t));

+      else

+	/* Standard memory.  */

+	a->d = gcry_xcalloc (nlimbs , sizeof (mpi_limb_t));

+    }

+  a->alloced = nlimbs;

+}

+

+void

+_gcry_mpi_clear( gcry_mpi_t a )

+{

+    a->nlimbs = 0;

+    a->flags = 0;

+}

+

+

+void

+_gcry_mpi_free( gcry_mpi_t a )

+{

+  if (!a )

+    return;

+  if ((a->flags & 4))

+    gcry_free( a->d );

+  else

+    {

+      _gcry_mpi_free_limb_space(a->d, a->alloced);

+    }

+  if ((a->flags & ~7))

+    log_bug("invalid flag value in mpi\n");

+  gcry_free(a);

+}

+

+static void

+mpi_set_secure( gcry_mpi_t a )

+{

+  mpi_ptr_t ap, bp;

+

+  if ( (a->flags & 1) )

+    return;

+  a->flags |= 1;

+  ap = a->d;

+  if (!a->nlimbs)

+    {

+      gcry_assert (!ap);

+      return;

+    }

+  bp = mpi_alloc_limb_space (a->nlimbs, 1);

+  MPN_COPY( bp, ap, a->nlimbs );

+  a->d = bp;

+  _gcry_mpi_free_limb_space (ap, a->alloced);

+}

+

+

+gcry_mpi_t

+gcry_mpi_set_opaque( gcry_mpi_t a, void *p, unsigned int nbits )

+{

+  if (!a) 

+    a = mpi_alloc(0);

+    

+  if( a->flags & 4 )

+    gcry_free( a->d );

+  else 

+    _gcry_mpi_free_limb_space (a->d, a->alloced);

+

+  a->d = p;

+  a->alloced = 0;

+  a->nlimbs = 0;

+  a->sign  = nbits;

+  a->flags = 4;

+  return a;

+}

+

+

+void *

+gcry_mpi_get_opaque( gcry_mpi_t a, unsigned int *nbits )

+{

+    if( !(a->flags & 4) )

+	log_bug("mpi_get_opaque on normal mpi\n");

+    if( nbits )

+	*nbits = a->sign;

+    return a->d;

+}

+

+

+/****************

+ * Note: This copy function should not interpret the MPI

+ *	 but copy it transparently.

+ */

+gcry_mpi_t

+gcry_mpi_copy( gcry_mpi_t a )

+{

+    int i;

+    gcry_mpi_t b;

+

+    if( a && (a->flags & 4) ) {

+	void *p = gcry_is_secure(a->d)? gcry_xmalloc_secure( (a->sign+7)/8 )

+				     : gcry_xmalloc( (a->sign+7)/8 );

+	memcpy( p, a->d, (a->sign+7)/8 );

+	b = gcry_mpi_set_opaque( NULL, p, a->sign );

+    }

+    else if( a ) {

+	b = mpi_is_secure(a)? mpi_alloc_secure( a->nlimbs )

+			    : mpi_alloc( a->nlimbs );

+	b->nlimbs = a->nlimbs;

+	b->sign = a->sign;

+	b->flags  = a->flags;

+	for(i=0; i < b->nlimbs; i++ )

+	    b->d[i] = a->d[i];

+    }

+    else

+	b = NULL;

+    return b;

+}

+

+

+/****************

+ * This function allocates an MPI which is optimized to hold

+ * a value as large as the one given in the argument and allocates it

+ * with the same flags as A.

+ */

+gcry_mpi_t

+_gcry_mpi_alloc_like( gcry_mpi_t a )

+{

+    gcry_mpi_t b;

+

+    if( a && (a->flags & 4) ) {

+	int n = (a->sign+7)/8;

+	void *p = gcry_is_secure(a->d)? gcry_malloc_secure( n )

+				     : gcry_malloc( n );

+	memcpy( p, a->d, n );

+	b = gcry_mpi_set_opaque( NULL, p, a->sign );

+    }

+    else if( a ) {

+	b = mpi_is_secure(a)? mpi_alloc_secure( a->nlimbs )

+			    : mpi_alloc( a->nlimbs );

+	b->nlimbs = 0;

+	b->sign = 0;

+	b->flags = a->flags;

+    }

+    else

+	b = NULL;

+    return b;

+}

+

+

+gcry_mpi_t

+gcry_mpi_set( gcry_mpi_t w, gcry_mpi_t u)

+{

+  mpi_ptr_t wp, up;

+  mpi_size_t usize = u->nlimbs;

+  int usign = u->sign;

+  

+  if (!w)

+    w = _gcry_mpi_alloc( mpi_get_nlimbs(u) );

+  RESIZE_IF_NEEDED(w, usize);

+  wp = w->d;

+  up = u->d;

+  MPN_COPY( wp, up, usize );

+  w->nlimbs = usize;

+  w->flags = u->flags;

+  w->sign = usign;

+  return w;

+}

+

+

+gcry_mpi_t

+gcry_mpi_set_ui( gcry_mpi_t w, unsigned long u)

+{

+  if (!w)

+    w = _gcry_mpi_alloc (1);

+  /* FIXME: If U is 0 we have no need to resize and thus possible

+     allocating the the limbs. */

+  RESIZE_IF_NEEDED(w, 1);

+  w->d[0] = u;

+  w->nlimbs = u? 1:0;

+  w->sign = 0;

+  w->flags = 0;

+  return w;

+}

+

+gcry_err_code_t

+_gcry_mpi_get_ui (gcry_mpi_t w, unsigned long *u)

+{

+  gcry_err_code_t err = GPG_ERR_NO_ERROR;

+  unsigned long x = 0;

+

+  if (w->nlimbs > 1)

+    err = GPG_ERR_TOO_LARGE;

+  else if (w->nlimbs == 1)

+    x = w->d[0];

+  else

+    x = 0;

+

+  if (! err)

+    *u = x;

+  

+  return err;

+}

+

+gcry_error_t

+gcry_mpi_get_ui (gcry_mpi_t w, unsigned long *u)

+{

+  gcry_err_code_t err = GPG_ERR_NO_ERROR;

+

+  err = _gcry_mpi_get_ui (w, u);

+  

+  return gcry_error (err);

+}

+

+gcry_mpi_t

+_gcry_mpi_alloc_set_ui( unsigned long u)

+{

+    gcry_mpi_t w = mpi_alloc(1);

+    w->d[0] = u;

+    w->nlimbs = u? 1:0;

+    w->sign = 0;

+    return w;

+}

+

+void

+gcry_mpi_swap( gcry_mpi_t a, gcry_mpi_t b)

+{

+    struct gcry_mpi tmp;

+

+    tmp = *a; *a = *b; *b = tmp;

+}

+

+

+gcry_mpi_t

+gcry_mpi_new( unsigned int nbits )

+{

+    return _gcry_mpi_alloc ( (nbits+BITS_PER_MPI_LIMB-1)

+                             / BITS_PER_MPI_LIMB );

+}

+

+

+gcry_mpi_t

+gcry_mpi_snew( unsigned int nbits )

+{

+  return _gcry_mpi_alloc_secure ( (nbits+BITS_PER_MPI_LIMB-1)

+                                  / BITS_PER_MPI_LIMB );

+}

+

+void

+gcry_mpi_release( gcry_mpi_t a )

+{

+    _gcry_mpi_free( a );

+}

+

+void

+gcry_mpi_randomize( gcry_mpi_t w,

+		    unsigned int nbits, enum gcry_random_level level )

+{

+  unsigned char *p;

+  size_t nbytes = (nbits+7)/8;

+  

+  if (level == GCRY_WEAK_RANDOM)

+    {

+      p = mpi_is_secure(w) ? gcry_xmalloc_secure (nbytes)

+                           : gcry_xmalloc (nbytes);

+      gcry_create_nonce (p, nbytes);

+    }

+  else

+    {

+      p = mpi_is_secure(w) ? gcry_random_bytes_secure (nbytes, level)

+                           : gcry_random_bytes (nbytes, level);

+    }

+  _gcry_mpi_set_buffer( w, p, nbytes, 0 );

+  gcry_free (p);

+}

+

+

+void

+gcry_mpi_set_flag( gcry_mpi_t a, enum gcry_mpi_flag flag )

+{

+    switch( flag ) {

+      case GCRYMPI_FLAG_SECURE:  mpi_set_secure(a); break;

+      case GCRYMPI_FLAG_OPAQUE:

+      default: log_bug("invalid flag value\n");

+    }

+}

+

+void

+gcry_mpi_clear_flag( gcry_mpi_t a, enum gcry_mpi_flag flag )

+{

+  (void)a; /* Not yet used. */

+

+  switch (flag)

+    {

+    case GCRYMPI_FLAG_SECURE:

+    case GCRYMPI_FLAG_OPAQUE:

+    default: log_bug("invalid flag value\n");

+    }

+}

+

+int

+gcry_mpi_get_flag( gcry_mpi_t a, enum gcry_mpi_flag flag )

+{

+  switch (flag)

+    {

+    case GCRYMPI_FLAG_SECURE: return (a->flags & 1);

+    case GCRYMPI_FLAG_OPAQUE: return (a->flags & 4);

+    default: log_bug("invalid flag value\n");

+    }

+  /*NOTREACHED*/

+  return 0;

+}

+