OpenSSL 0.9.5 merge

*warning* this bumps shared lib minors for libssl and libcrypto from 2.1 to 2.2
if you are using the ssl26 packages for ssh and other things to work you will
need to get new ones (see ~beck/libsslsnap/<arch>) on cvs or ~beck/src-patent.tar.gz on cvs

48 files changed, 3591 insertions, 4847 deletions

diff --git a/src/lib/libcrypto/bn/Makefile.ssl b/src/lib/libcrypto/bn/Makefile.ssl
index cf77869fab..fa23a43fa0 100644
--- a/src/lib/libcrypto/bn/Makefile.ssl
+++ b/src/lib/libcrypto/bn/Makefile.ssl
@@ -20,6 +20,13 @@ BN_ASM=		bn_asm.o
 #BN_ASM=        bn86-elf.o
 
 CFLAGS= $(INCLUDES) $(CFLAG)
+
+# We let the C compiler driver to take care of .s files. This is done in
+# order to be excused from maintaining a separate set of architecture
+# dependent assembler flags. E.g. if you throw -mcpu=ultrasparc at SPARC
+# gcc, then the driver will automatically translate it to -xarch=v8plus
+# and pass it down to assembler.
+AS=$(CC) -c
 ASFLAGS=$(CFLAGS)
 
 GENERAL=Makefile
@@ -27,12 +34,12 @@ TEST=bntest.c exptest.c
 APPS=
 
 LIB=$(TOP)/libcrypto.a
-LIBSRC= bn_add.c bn_div.c bn_exp.c bn_lib.c bn_mul.c \
+LIBSRC= bn_add.c bn_div.c bn_exp.c bn_lib.c bn_ctx.c bn_mul.c \
         bn_print.c bn_rand.c bn_shift.c bn_word.c bn_blind.c \
         bn_gcd.c bn_prime.c bn_err.c bn_sqr.c bn_asm.c bn_recp.c bn_mont.c \
         bn_mpi.c bn_exp2.c
 
-LIBOBJ= bn_add.o bn_div.o bn_exp.o bn_lib.o bn_mul.o \
+LIBOBJ= bn_add.o bn_div.o bn_exp.o bn_lib.o bn_ctx.o bn_mul.o \
         bn_print.o bn_rand.o bn_shift.o bn_word.o bn_blind.o \
         bn_gcd.o bn_prime.o bn_err.o bn_sqr.o $(BN_ASM) bn_recp.o bn_mont.o \
         bn_mpi.o bn_exp2.o
@@ -49,12 +56,14 @@ top:
 
 all:    lib
 
-knuth: bn_knuth.c
-        cc -pg -I.. -I../../include bn_knuth.c -o knuth $(LIB) #../../../libefence.a
+bn_prime.h: bn_prime.pl
+        $(PERL) bn_prime.pl >bn_prime.h
 
-knuth.fast: bn_knuth.c
-        cc -pg -fast -I.. -I../../include bn_knuth.c -o knuth $(LIB) #../../../libefence.a
+divtest: divtest.c ../../libcrypto.a
+        cc -I../../include divtest.c -o divtest ../../libcrypto.a
 
+bnbug: bnbug.c ../../libcrypto.a top
+        cc -g -I../../include bnbug.c -o bnbug ../../libcrypto.a
 
 lib:    $(LIBOBJ)
         $(AR) $(LIB) $(LIBOBJ)
@@ -113,13 +122,6 @@ asm/sparcv8plus-gcc27.o: asm/sparcv8plus.S
         $(CC) $(ASFLAGS) -E asm/sparcv8plus.S | \
                 /usr/ccs/bin/as -xarch=v8plus - -o asm/sparcv8plus-gcc27.o
 
-# MIPS 64 bit assember 
-asm/mips3.o: asm/mips3.s
-
-# MIPS 32 bit assember
-asm/mips1.o: asm/mips1.s
-        /usr/bin/as -O2 -o asm/mips1.o asm/mips1.s
-
 files:
         $(PERL) $(TOP)/util/files.pl Makefile.ssl >> $(TOP)/MINFO
 
@@ -168,109 +170,117 @@ bn_add.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_add.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_add.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_add.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_add.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_add.o: ../cryptlib.h bn_lcl.h
+bn_add.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_add.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_asm.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_asm.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_asm.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_asm.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_asm.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_asm.o: ../cryptlib.h bn_lcl.h
+bn_asm.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_asm.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_blind.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_blind.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_blind.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_blind.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_blind.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_blind.o: ../cryptlib.h bn_lcl.h
+bn_blind.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_blind.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
+bn_ctx.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
+bn_ctx.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
+bn_ctx.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+bn_ctx.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
+bn_ctx.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_ctx.o: ../../include/openssl/stack.h ../cryptlib.h
 bn_div.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_div.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_div.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_div.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_div.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_div.o: ../cryptlib.h bn_lcl.h
+bn_div.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_div.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_err.o: ../../include/openssl/bn.h ../../include/openssl/err.h
 bn_err.o: ../../include/openssl/opensslconf.h
 bn_exp.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_exp.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_exp.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_exp.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_exp.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_exp.o: ../cryptlib.h bn_lcl.h
+bn_exp.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_exp.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_exp2.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_exp2.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_exp2.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_exp2.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_exp2.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_exp2.o: ../cryptlib.h bn_lcl.h
+bn_exp2.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_exp2.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_gcd.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_gcd.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_gcd.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_gcd.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_gcd.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_gcd.o: ../cryptlib.h bn_lcl.h
+bn_gcd.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_gcd.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_lib.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_lib.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_lib.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_lib.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_lib.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_lib.o: ../cryptlib.h bn_lcl.h
+bn_lib.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_lib.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_mont.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_mont.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_mont.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_mont.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_mont.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_mont.o: ../cryptlib.h bn_lcl.h
+bn_mont.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_mont.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_mpi.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_mpi.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_mpi.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_mpi.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_mpi.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_mpi.o: ../cryptlib.h bn_lcl.h
+bn_mpi.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_mpi.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_mul.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_mul.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_mul.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_mul.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_mul.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_mul.o: ../cryptlib.h bn_lcl.h
+bn_mul.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_mul.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_prime.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_prime.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_prime.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_prime.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
 bn_prime.o: ../../include/openssl/opensslv.h ../../include/openssl/rand.h
-bn_prime.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h bn_prime.h
+bn_prime.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
+bn_prime.o: ../cryptlib.h bn_lcl.h bn_prime.h
 bn_print.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_print.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_print.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_print.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_print.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_print.o: ../cryptlib.h bn_lcl.h
+bn_print.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_print.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_rand.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_rand.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_rand.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_rand.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
 bn_rand.o: ../../include/openssl/opensslv.h ../../include/openssl/rand.h
-bn_rand.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
+bn_rand.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
+bn_rand.o: ../cryptlib.h bn_lcl.h
 bn_recp.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_recp.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_recp.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_recp.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_recp.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_recp.o: ../cryptlib.h bn_lcl.h
+bn_recp.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_recp.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_shift.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_shift.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_shift.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_shift.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_shift.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_shift.o: ../cryptlib.h bn_lcl.h
+bn_shift.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_shift.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_sqr.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_sqr.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_sqr.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_sqr.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_sqr.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_sqr.o: ../cryptlib.h bn_lcl.h
+bn_sqr.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_sqr.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
 bn_word.o: ../../include/openssl/bio.h ../../include/openssl/bn.h
 bn_word.o: ../../include/openssl/buffer.h ../../include/openssl/crypto.h
 bn_word.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
 bn_word.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
-bn_word.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
-bn_word.o: ../cryptlib.h bn_lcl.h
+bn_word.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bn_word.o: ../../include/openssl/stack.h ../cryptlib.h bn_lcl.h
diff --git a/src/lib/libcrypto/bn/asm/README b/src/lib/libcrypto/bn/asm/README
index d93fbff77f..86bf64cfc2 100644
--- a/src/lib/libcrypto/bn/asm/README
+++ b/src/lib/libcrypto/bn/asm/README
@@ -1,5 +1,5 @@
 All assember in this directory are just version of the file
-crypto/bn/bn_mulw.c.
+crypto/bn/bn_asm.c.
 
 Quite a few of these files are just the assember output from gcc since on 
 quite a few machines they are 2 times faster than the system compiler.
@@ -15,13 +15,6 @@ On the 2 alpha C compilers I had access to, it was not possible to do
 were 64 bits).  So the hand assember gives access to the 128 bit result and
 a 2 times speedup :-).
 
-The x86xxxx.obj files are the assembled version of x86xxxx.asm files.
-I had such a hard time finding a macro assember for Microsoft, I decided to
-include the object file to save others the hassle :-).
-
-I have also included uu encoded versions of the .obj incase they get
-trashed.
-
 There are 2 versions of assember for the HP PA-RISC.
 pa-risc.s is the origional one which works fine.
 pa-risc2.s is a new version that often generates warnings but if the
diff --git a/src/lib/libcrypto/bn/asm/alpha.s b/src/lib/libcrypto/bn/asm/alpha.s
index a351694ca2..555ff0b92d 100644
--- a/src/lib/libcrypto/bn/asm/alpha.s
+++ b/src/lib/libcrypto/bn/asm/alpha.s
@@ -694,567 +694,1868 @@ bn_mul_comba8:
 bn_mul_comba8..ng:
         .frame $30,0,$26,0
         .prologue 0
-
-        subq    $30,    16,     $30
-        ldq     $0,     0($17)
+        ldq     $1,     0($17)
+        ldq     $2,     0($18)
+        zapnot  $1,     15,     $7
+        srl     $2,     32,     $8
+        mulq    $8,     $7,     $22
+        srl     $1,     32,     $6
+        zapnot  $2,     15,     $5
+        mulq    $5,     $6,     $4
+        mulq    $7,     $5,     $24
+        addq    $22,    $4,     $22
+        cmpult  $22,    $4,     $1
+        mulq    $6,     $8,     $3
+        beq     $1,     $173
+        bis     $31,    1,      $1
+        sll     $1,     32,     $1
+        addq    $3,     $1,     $3
+$173:
+        sll     $22,    32,     $4
+        addq    $24,    $4,     $24
+        stq     $24,    0($16)
+        ldq     $2,     0($17)
+        ldq     $1,     8($18)
+        zapnot  $2,     15,     $7
+        srl     $1,     32,     $8
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $0
+        srl     $2,     32,     $6
+        mulq    $5,     $6,     $23
+        mulq    $6,     $8,     $6
+        srl     $22,    32,     $1
+        cmpult  $24,    $4,     $2
+        addq    $3,     $1,     $3
+        addq    $2,     $3,     $22
+        addq    $25,    $23,    $25
+        cmpult  $25,    $23,    $1
+        bis     $31,    1,      $2
+        beq     $1,     $177
+        sll     $2,     32,     $1
+        addq    $6,     $1,     $6
+$177:
+        sll     $25,    32,     $23
         ldq     $1,     0($18)
-        stq     $9,     0($30)
-        stq     $10,    8($30)
-        ldq     $2,     8($17)
-        ldq     $3,     8($18)
-        ldq     $4,     16($17)
-        ldq     $5,     16($18)
-        ldq     $6,     24($17)
-        ldq     $7,     24($18)
-        ldq     $8,     8($17)
-        ldq     $22,    8($18)
-        ldq     $23,    8($17)
-        ldq     $24,    8($18)
-        ldq     $25,    8($17)
-        ldq     $27,    8($18)
-        ldq     $28,    8($17)
-        ldq     $21,    8($18)
-        bis     $31,    $31,    $9
-        mulq    $0,     $1,     $20
-        umulh   $0,     $1,     $19
-        stq     $20,    0($16)
-        bis     $31,    $31,    $20
-        mulq    $0,     $3,     $10
-        umulh   $0,     $3,     $17
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $10
-        addq    $20,    $10,    $20
-        mulq    $2,     $1,     $18
-        umulh   $2,     $1,     $17
-        addq    $19,    $18,    $19
-        cmpult  $19,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $18
-        addq    $20,    $18,    $20
-        stq     $19,    8($16)
-        bis     $31,    $31,    $19
-        mulq    $0,     $5,     $10
-        umulh   $0,     $5,     $17
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $18
-        addq    $18,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $10
-        addq    $19,    $10,    $19
-        mulq    $2,     $3,     $18
-        umulh   $2,     $3,     $17
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $10
-        addq    $10,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $18
-        addq    $19,    $18,    $19
-        mulq    $4,     $1,     $10
-        umulh   $4,     $1,     $17
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $18
-        addq    $18,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $10
-        addq    $19,    $10,    $19
-        stq     $9,     16($16)
-        bis     $31,    $31,    $9
-        mulq    $0,     $7,     $18
-        umulh   $0,     $7,     $17
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $18
-        addq    $9,     $18,    $9
-        mulq    $2,     $5,     $10
-        umulh   $2,     $5,     $17
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $10
-        addq    $9,     $10,    $9
-        mulq    $4,     $3,     $18
-        umulh   $4,     $3,     $17
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $18
-        addq    $9,     $18,    $9
-        mulq    $6,     $1,     $10
-        umulh   $6,     $1,     $17
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $10
-        addq    $9,     $10,    $9
-        stq     $20,    24($16)
-        bis     $31,    $31,    $20
-        mulq    $0,     $22,    $18
-        umulh   $0,     $22,    $17
-        addq    $19,    $18,    $19
-        cmpult  $19,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $18
-        addq    $20,    $18,    $20
-        mulq    $2,     $7,     $10
-        umulh   $2,     $7,     $17
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $10
-        addq    $20,    $10,    $20
-        mulq    $4,     $5,     $18
-        umulh   $4,     $5,     $17
-        addq    $19,    $18,    $19
-        cmpult  $19,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $18
-        addq    $20,    $18,    $20
-        mulq    $6,     $3,     $10
-        umulh   $6,     $3,     $17
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $10
-        addq    $20,    $10,    $20
-        mulq    $8,     $1,     $18
-        umulh   $8,     $1,     $17
-        addq    $19,    $18,    $19
-        cmpult  $19,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $18
-        addq    $20,    $18,    $20
-        stq     $19,    32($16)
-        bis     $31,    $31,    $19
-        mulq    $0,     $24,    $10
-        umulh   $0,     $24,    $17
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $18
-        addq    $18,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $10
-        addq    $19,    $10,    $19
-        mulq    $2,     $22,    $18
-        umulh   $2,     $22,    $17
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $10
-        addq    $10,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $18
-        addq    $19,    $18,    $19
-        mulq    $4,     $7,     $10
-        umulh   $4,     $7,     $17
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $18
-        addq    $18,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $10
-        addq    $19,    $10,    $19
-        mulq    $6,     $5,     $18
-        umulh   $6,     $5,     $17
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $10
-        addq    $10,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $18
-        addq    $19,    $18,    $19
-        mulq    $8,     $3,     $10
-        umulh   $8,     $3,     $17
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $18
-        addq    $18,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $10
-        addq    $19,    $10,    $19
-        mulq    $23,    $1,     $18
-        umulh   $23,    $1,     $17
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $10
-        addq    $10,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $18
-        addq    $19,    $18,    $19
-        stq     $9,     40($16)
-        bis     $31,    $31,    $9
-        mulq    $0,     $27,    $10
-        umulh   $0,     $27,    $17
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $10
-        addq    $9,     $10,    $9
-        mulq    $2,     $24,    $18
-        umulh   $2,     $24,    $17
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $18
-        addq    $9,     $18,    $9
-        mulq    $4,     $22,    $10
-        umulh   $4,     $22,    $17
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $10
-        addq    $9,     $10,    $9
-        mulq    $6,     $7,     $18
-        umulh   $6,     $7,     $17
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $18
-        addq    $9,     $18,    $9
-        mulq    $8,     $5,     $10
-        umulh   $8,     $5,     $17
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $10
-        addq    $9,     $10,    $9
-        mulq    $23,    $3,     $18
-        umulh   $23,    $3,     $17
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $18
-        addq    $9,     $18,    $9
-        mulq    $25,    $1,     $10
-        umulh   $25,    $1,     $17
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $10
-        addq    $9,     $10,    $9
-        stq     $20,    48($16)
-        bis     $31,    $31,    $20
-        mulq    $0,     $21,    $18
-        umulh   $0,     $21,    $17
-        addq    $19,    $18,    $19
-        cmpult  $19,    $18,    $10
-        addq    $10,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $18
-        addq    $20,    $18,    $20
-        mulq    $2,     $27,    $10
-        umulh   $2,     $27,    $17
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $0
-        addq    $20,    $0,     $20
-        mulq    $4,     $24,    $10
-        umulh   $4,     $24,    $18
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $17
-        addq    $17,    $18,    $18
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $0
-        addq    $20,    $0,     $20
-        mulq    $6,     $22,    $10
-        umulh   $6,     $22,    $17
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $0
-        addq    $20,    $0,     $20
-        mulq    $8,     $7,     $10
-        umulh   $8,     $7,     $18
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $17
-        addq    $17,    $18,    $18
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $0
-        addq    $20,    $0,     $20
-        mulq    $23,    $5,     $10
-        umulh   $23,    $5,     $17
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $0
-        addq    $20,    $0,     $20
-        mulq    $25,    $3,     $10
-        umulh   $25,    $3,     $18
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $17
-        addq    $17,    $18,    $18
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $0
-        addq    $20,    $0,     $20
-        mulq    $28,    $1,     $10
-        umulh   $28,    $1,     $17
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $0
-        addq    $20,    $0,     $20
-        stq     $19,    56($16)
-        bis     $31,    $31,    $19
-        mulq    $2,     $21,    $10
-        umulh   $2,     $21,    $18
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $17
-        addq    $17,    $18,    $18
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $0
-        addq    $19,    $0,     $19
-        mulq    $4,     $27,    $1
-        umulh   $4,     $27,    $10
-        addq    $9,     $1,     $9
-        cmpult  $9,     $1,     $17
-        addq    $17,    $10,    $10
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $18
-        addq    $19,    $18,    $19
-        mulq    $6,     $24,    $0
-        umulh   $6,     $24,    $2
-        addq    $9,     $0,     $9
-        cmpult  $9,     $0,     $1
-        addq    $1,     $2,     $2
-        addq    $20,    $2,     $20
-        cmpult  $20,    $2,     $17
-        addq    $19,    $17,    $19
-        mulq    $8,     $22,    $10
-        umulh   $8,     $22,    $18
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $0
-        addq    $0,     $18,    $18
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $1
-        addq    $19,    $1,     $19
-        mulq    $23,    $7,     $2
-        umulh   $23,    $7,     $17
-        addq    $9,     $2,     $9
-        cmpult  $9,     $2,     $10
-        addq    $10,    $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $0
-        addq    $19,    $0,     $19
-        mulq    $25,    $5,     $18
-        umulh   $25,    $5,     $1
-        addq    $9,     $18,    $9
-        cmpult  $9,     $18,    $2
-        addq    $2,     $1,     $1
-        addq    $20,    $1,     $20
-        cmpult  $20,    $1,     $10
-        addq    $19,    $10,    $19
-        mulq    $28,    $3,     $17
-        umulh   $28,    $3,     $0
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $18
-        addq    $18,    $0,     $0
-        addq    $20,    $0,     $20
-        cmpult  $20,    $0,     $2
-        addq    $19,    $2,     $19
-        stq     $9,     64($16)
-        bis     $31,    $31,    $9
-        mulq    $4,     $21,    $1
-        umulh   $4,     $21,    $10
-        addq    $20,    $1,     $20
-        cmpult  $20,    $1,     $17
-        addq    $17,    $10,    $10
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $18
-        addq    $9,     $18,    $9
-        mulq    $6,     $27,    $0
-        umulh   $6,     $27,    $2
-        addq    $20,    $0,     $20
-        cmpult  $20,    $0,     $3
-        addq    $3,     $2,     $2
-        addq    $19,    $2,     $19
-        cmpult  $19,    $2,     $1
-        addq    $9,     $1,     $9
-        mulq    $8,     $24,    $17
-        umulh   $8,     $24,    $10
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $18
-        addq    $18,    $10,    $10
-        addq    $19,    $10,    $19
-        cmpult  $19,    $10,    $4
-        addq    $9,     $4,     $9
-        mulq    $23,    $22,    $0
-        umulh   $23,    $22,    $3
-        addq    $20,    $0,     $20
-        cmpult  $20,    $0,     $2
-        addq    $2,     $3,     $3
-        addq    $19,    $3,     $19
-        cmpult  $19,    $3,     $1
-        addq    $9,     $1,     $9
-        mulq    $25,    $7,     $17
-        umulh   $25,    $7,     $18
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $10
-        addq    $10,    $18,    $18
-        addq    $19,    $18,    $19
-        cmpult  $19,    $18,    $4
-        addq    $9,     $4,     $9
-        mulq    $28,    $5,     $0
-        umulh   $28,    $5,     $2
-        addq    $20,    $0,     $20
-        cmpult  $20,    $0,     $3
-        addq    $3,     $2,     $2
-        addq    $19,    $2,     $19
-        cmpult  $19,    $2,     $1
-        addq    $9,     $1,     $9
-        stq     $20,    72($16)
-        bis     $31,    $31,    $20
-        mulq    $6,     $21,    $17
-        umulh   $6,     $21,    $10
-        addq    $19,    $17,    $19
-        cmpult  $19,    $17,    $18
-        addq    $18,    $10,    $10
-        addq    $9,     $10,    $9
-        cmpult  $9,     $10,    $4
-        addq    $20,    $4,     $20
-        mulq    $8,     $27,    $0
-        umulh   $8,     $27,    $3
-        addq    $19,    $0,     $19
-        cmpult  $19,    $0,     $2
-        addq    $2,     $3,     $3
-        addq    $9,     $3,     $9
-        cmpult  $9,     $3,     $1
-        addq    $20,    $1,     $20
-        mulq    $23,    $24,    $5
-        umulh   $23,    $24,    $17
-        addq    $19,    $5,     $19
-        cmpult  $19,    $5,     $18
-        addq    $18,    $17,    $17
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $10
-        addq    $20,    $10,    $20
-        mulq    $25,    $22,    $4
-        umulh   $25,    $22,    $6
-        addq    $19,    $4,     $19
-        cmpult  $19,    $4,     $0
-        addq    $0,     $6,     $6
-        addq    $9,     $6,     $9
-        cmpult  $9,     $6,     $2
-        addq    $20,    $2,     $20
-        mulq    $28,    $7,     $3
-        umulh   $28,    $7,     $1
-        addq    $19,    $3,     $19
-        cmpult  $19,    $3,     $5
-        addq    $5,     $1,     $1
-        addq    $9,     $1,     $9
-        cmpult  $9,     $1,     $18
-        addq    $20,    $18,    $20
-        stq     $19,    80($16)
-        bis     $31,    $31,    $19
-        mulq    $8,     $21,    $17
-        umulh   $8,     $21,    $10
-        addq    $9,     $17,    $9
-        cmpult  $9,     $17,    $4
-        addq    $4,     $10,    $10
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $0
-        addq    $19,    $0,     $19
-        mulq    $23,    $27,    $6
-        umulh   $23,    $27,    $2
-        addq    $9,     $6,     $9
-        cmpult  $9,     $6,     $3
-        addq    $3,     $2,     $2
+        addq    $0,     $23,    $0
+        bis     $0,     $0,     $7
+        ldq     $3,     8($17)
+        addq    $22,    $7,     $22
+        srl     $1,     32,     $8
+        cmpult  $22,    $7,     $4
+        zapnot  $3,     15,     $7
+        mulq    $8,     $7,     $28
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $21
+        srl     $25,    32,     $1
+        cmpult  $0,     $23,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $4,     $6,     $24
+        srl     $3,     32,     $6
+        mulq    $5,     $6,     $2
+        mulq    $6,     $8,     $6
+        addq    $28,    $2,     $28
+        cmpult  $28,    $2,     $1
+        bis     $31,    1,      $2
+        beq     $1,     $181
+        sll     $2,     32,     $1
+        addq    $6,     $1,     $6
+$181:
+        sll     $28,    32,     $2
+        addq    $21,    $2,     $21
+        bis     $21,    $21,    $7
+        addq    $22,    $7,     $22
+        stq     $22,    8($16)
+        ldq     $3,     16($17)
+        ldq     $1,     0($18)
+        cmpult  $22,    $7,     $4
+        zapnot  $3,     15,     $7
+        srl     $1,     32,     $8
+        mulq    $8,     $7,     $22
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $20
+        srl     $28,    32,     $1
+        cmpult  $21,    $2,     $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $4,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $23
+        srl     $3,     32,     $6
+        mulq    $5,     $6,     $2
+        mulq    $6,     $8,     $6
+        addq    $22,    $2,     $22
+        cmpult  $22,    $2,     $1
+        bis     $31,    1,      $2
+        beq     $1,     $185
+        sll     $2,     32,     $1
+        addq    $6,     $1,     $6
+$185:
+        sll     $22,    32,     $2
+        ldq     $1,     8($18)
         addq    $20,    $2,     $20
-        cmpult  $20,    $2,     $5
-        addq    $19,    $5,     $19
-        mulq    $25,    $24,    $1
-        umulh   $25,    $24,    $18
-        addq    $9,     $1,     $9
-        cmpult  $9,     $1,     $7
-        addq    $7,     $18,    $18
-        addq    $20,    $18,    $20
-        cmpult  $20,    $18,    $17
-        addq    $19,    $17,    $19
-        mulq    $28,    $22,    $4
-        umulh   $28,    $22,    $10
-        addq    $9,     $4,     $9
-        cmpult  $9,     $4,     $0
-        addq    $0,     $10,    $10
-        addq    $20,    $10,    $20
-        cmpult  $20,    $10,    $8
-        addq    $19,    $8,     $19
-        stq     $9,     88($16)
-        bis     $31,    $31,    $9
-        mulq    $23,    $21,    $6
-        umulh   $23,    $21,    $3
-        addq    $20,    $6,     $20
-        cmpult  $20,    $6,     $2
-        addq    $2,     $3,     $3
-        addq    $19,    $3,     $19
-        cmpult  $19,    $3,     $5
-        addq    $9,     $5,     $9
-        mulq    $25,    $27,    $1
-        umulh   $25,    $27,    $7
-        addq    $20,    $1,     $20
-        cmpult  $20,    $1,     $18
-        addq    $18,    $7,     $7
-        addq    $19,    $7,     $19
-        cmpult  $19,    $7,     $17
-        addq    $9,     $17,    $9
-        mulq    $28,    $24,    $4
-        umulh   $28,    $24,    $0
-        addq    $20,    $4,     $20
-        cmpult  $20,    $4,     $10
-        addq    $10,    $0,     $0
-        addq    $19,    $0,     $19
-        cmpult  $19,    $0,     $8
-        addq    $9,     $8,     $9
-        stq     $20,    96($16)
-        bis     $31,    $31,    $20
-        mulq    $25,    $21,    $22
-        umulh   $25,    $21,    $6
-        addq    $19,    $22,    $19
-        cmpult  $19,    $22,    $2
+        bis     $20,    $20,    $7
+        ldq     $4,     8($17)
+        addq    $24,    $7,     $24
+        srl     $1,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $0
+        srl     $22,    32,     $1
+        cmpult  $20,    $2,     $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $22
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $21
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $189
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$189:
+        sll     $25,    32,     $5
+        ldq     $2,     16($18)
+        addq    $0,     $5,     $0
+        bis     $0,     $0,     $7
+        ldq     $4,     0($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $0,     $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $22,    $22
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $193
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$193:
+        sll     $28,    32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $24,    $7,     $24
+        stq     $24,    16($16)
+        ldq     $4,     0($17)
+        ldq     $5,     24($18)
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $24
+        mulq    $7,     $5,     $2
+        addq    $1,     $22,    $22
+        addq    $0,     $24,    $0
+        cmpult  $0,     $24,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $197
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$197:
+        sll     $0,     32,     $24
+        ldq     $1,     16($18)
+        addq    $2,     $24,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     8($17)
+        addq    $23,    $7,     $23
+        srl     $1,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $21
+        srl     $0,     32,     $1
+        cmpult  $2,     $24,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $24
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $20
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $201
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$201:
+        sll     $25,    32,     $5
+        ldq     $2,     8($18)
+        addq    $21,    $5,     $21
+        bis     $21,    $21,    $7
+        ldq     $4,     16($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $21,    $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $205
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$205:
+        sll     $28,    32,     $25
+        ldq     $2,     0($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     24($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $24,    $24
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $209
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$209:
+        sll     $0,     32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $23,    $7,     $23
+        stq     $23,    24($16)
+        ldq     $4,     32($17)
+        ldq     $5,     0($18)
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $23
+        mulq    $7,     $5,     $2
+        addq    $1,     $24,    $24
+        addq    $28,    $23,    $28
+        cmpult  $28,    $23,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $213
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$213:
+        sll     $28,    32,     $23
+        ldq     $1,     8($18)
+        addq    $2,     $23,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     24($17)
+        addq    $22,    $7,     $22
+        srl     $1,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $23,    $2
+        addq    $6,     $1,     $6
         addq    $2,     $6,     $6
-        addq    $9,     $6,     $9
-        cmpult  $9,     $6,     $3
-        addq    $20,    $3,     $20
-        mulq    $28,    $27,    $5
-        umulh   $28,    $27,    $23
-        addq    $19,    $5,     $19
-        cmpult  $19,    $5,     $1
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $23
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $21
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $217
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$217:
+        sll     $25,    32,     $5
+        ldq     $2,     16($18)
+        addq    $0,     $5,     $0
+        bis     $0,     $0,     $7
+        ldq     $4,     16($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $0,     $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
         addq    $1,     $23,    $23
-        addq    $9,     $23,    $9
-        cmpult  $9,     $23,    $18
-        addq    $20,    $18,    $20
-        stq     $19,    104($16)
-        bis     $31,    $31,    $19
-        mulq    $28,    $21,    $7
-        umulh   $28,    $21,    $17
-        addq    $9,     $7,     $9
-        cmpult  $9,     $7,     $4
-        addq    $4,     $17,    $17
-        addq    $20,    $17,    $20
-        cmpult  $20,    $17,    $10
-        addq    $19,    $10,    $19
-        stq     $9,     112($16)
-        stq     $20,    120($16)
-        ldq     $9,     0($30)
-        ldq     $10,    8($30)
-        addq    $30,    16,     $30
-        ret     $31,($26),1
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $221
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$221:
+        sll     $28,    32,     $25
+        ldq     $2,     24($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     8($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $225
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$225:
+        sll     $0,     32,     $25
+        ldq     $2,     32($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     0($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $23,    $23
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $229
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$229:
+        sll     $28,    32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $22,    $7,     $22
+        stq     $22,    32($16)
+        ldq     $4,     0($17)
+        ldq     $5,     40($18)
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $22
+        mulq    $7,     $5,     $2
+        addq    $1,     $23,    $23
+        addq    $0,     $22,    $0
+        cmpult  $0,     $22,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $233
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$233:
+        sll     $0,     32,     $22
+        ldq     $1,     32($18)
+        addq    $2,     $22,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     8($17)
+        addq    $24,    $7,     $24
+        srl     $1,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $21
+        srl     $0,     32,     $1
+        cmpult  $2,     $22,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $22
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $20
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $237
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$237:
+        sll     $25,    32,     $5
+        ldq     $2,     24($18)
+        addq    $21,    $5,     $21
+        bis     $21,    $21,    $7
+        ldq     $4,     16($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $21,    $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $241
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$241:
+        sll     $28,    32,     $25
+        ldq     $2,     16($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     24($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $245
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$245:
+        sll     $0,     32,     $25
+        ldq     $2,     8($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     32($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $249
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$249:
+        sll     $28,    32,     $25
+        ldq     $2,     0($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     40($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $22,    $22
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $253
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$253:
+        sll     $0,     32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $24,    $7,     $24
+        stq     $24,    40($16)
+        ldq     $4,     48($17)
+        ldq     $5,     0($18)
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $24
+        mulq    $7,     $5,     $2
+        addq    $1,     $22,    $22
+        addq    $28,    $24,    $28
+        cmpult  $28,    $24,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $257
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$257:
+        sll     $28,    32,     $24
+        ldq     $1,     8($18)
+        addq    $2,     $24,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     40($17)
+        addq    $23,    $7,     $23
+        srl     $1,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $24,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $24
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $21
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $261
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$261:
+        sll     $25,    32,     $5
+        ldq     $2,     16($18)
+        addq    $0,     $5,     $0
+        bis     $0,     $0,     $7
+        ldq     $4,     32($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $0,     $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $265
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$265:
+        sll     $28,    32,     $25
+        ldq     $2,     24($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     24($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $269
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$269:
+        sll     $0,     32,     $25
+        ldq     $2,     32($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     16($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $273
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$273:
+        sll     $28,    32,     $25
+        ldq     $2,     40($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     8($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $277
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$277:
+        sll     $0,     32,     $25
+        ldq     $2,     48($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     0($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $24,    $24
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $281
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$281:
+        sll     $28,    32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $23,    $7,     $23
+        stq     $23,    48($16)
+        ldq     $4,     0($17)
+        ldq     $5,     56($18)
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $23
+        mulq    $7,     $5,     $2
+        addq    $1,     $24,    $24
+        addq    $0,     $23,    $0
+        cmpult  $0,     $23,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $285
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$285:
+        sll     $0,     32,     $23
+        ldq     $1,     48($18)
+        addq    $2,     $23,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     8($17)
+        addq    $22,    $7,     $22
+        srl     $1,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $21
+        srl     $0,     32,     $1
+        cmpult  $2,     $23,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $23
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $20
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $289
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$289:
+        sll     $25,    32,     $5
+        ldq     $2,     40($18)
+        addq    $21,    $5,     $21
+        bis     $21,    $21,    $7
+        ldq     $4,     16($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $21,    $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $293
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$293:
+        sll     $28,    32,     $25
+        ldq     $2,     32($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     24($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $297
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$297:
+        sll     $0,     32,     $25
+        ldq     $2,     24($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     32($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $301
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$301:
+        sll     $28,    32,     $25
+        ldq     $2,     16($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     40($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $305
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$305:
+        sll     $0,     32,     $25
+        ldq     $2,     8($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     48($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $309
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$309:
+        sll     $28,    32,     $25
+        ldq     $2,     0($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     56($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $23,    $23
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $313
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$313:
+        sll     $0,     32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $22,    $7,     $22
+        stq     $22,    56($16)
+        ldq     $4,     56($17)
+        ldq     $5,     8($18)
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $22
+        mulq    $7,     $5,     $2
+        addq    $1,     $23,    $23
+        addq    $28,    $22,    $28
+        cmpult  $28,    $22,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $317
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$317:
+        sll     $28,    32,     $22
+        ldq     $1,     16($18)
+        addq    $2,     $22,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     48($17)
+        addq    $24,    $7,     $24
+        srl     $1,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $22,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $22
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $21
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $321
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$321:
+        sll     $25,    32,     $5
+        ldq     $2,     24($18)
+        addq    $0,     $5,     $0
+        bis     $0,     $0,     $7
+        ldq     $4,     40($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $0,     $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $325
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$325:
+        sll     $28,    32,     $25
+        ldq     $2,     32($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     32($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $329
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$329:
+        sll     $0,     32,     $25
+        ldq     $2,     40($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     24($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $333
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$333:
+        sll     $28,    32,     $25
+        ldq     $2,     48($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     16($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $337
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$337:
+        sll     $0,     32,     $25
+        ldq     $2,     56($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     8($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $22,    $22
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $341
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$341:
+        sll     $28,    32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $24,    $7,     $24
+        stq     $24,    64($16)
+        ldq     $4,     16($17)
+        ldq     $5,     56($18)
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $24
+        mulq    $7,     $5,     $2
+        addq    $1,     $22,    $22
+        addq    $0,     $24,    $0
+        cmpult  $0,     $24,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $345
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$345:
+        sll     $0,     32,     $24
+        ldq     $1,     48($18)
+        addq    $2,     $24,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     24($17)
+        addq    $23,    $7,     $23
+        srl     $1,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $21
+        srl     $0,     32,     $1
+        cmpult  $2,     $24,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $24
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $20
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $349
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$349:
+        sll     $25,    32,     $5
+        ldq     $2,     40($18)
+        addq    $21,    $5,     $21
+        bis     $21,    $21,    $7
+        ldq     $4,     32($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $21,    $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $353
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$353:
+        sll     $28,    32,     $25
+        ldq     $2,     32($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     40($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $357
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$357:
+        sll     $0,     32,     $25
+        ldq     $2,     24($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     48($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $361
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$361:
+        sll     $28,    32,     $25
+        ldq     $2,     16($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     56($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $24,    $24
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $365
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$365:
+        sll     $0,     32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $23,    $7,     $23
+        stq     $23,    72($16)
+        ldq     $4,     56($17)
+        ldq     $5,     24($18)
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $23
+        mulq    $7,     $5,     $2
+        addq    $1,     $24,    $24
+        addq    $28,    $23,    $28
+        cmpult  $28,    $23,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $369
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$369:
+        sll     $28,    32,     $23
+        ldq     $1,     32($18)
+        addq    $2,     $23,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     48($17)
+        addq    $22,    $7,     $22
+        srl     $1,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $23,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $23
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $21
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $373
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$373:
+        sll     $25,    32,     $5
+        ldq     $2,     40($18)
+        addq    $0,     $5,     $0
+        bis     $0,     $0,     $7
+        ldq     $4,     40($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $0,     $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $377
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$377:
+        sll     $28,    32,     $25
+        ldq     $2,     48($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     32($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $23,    $23
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $381
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$381:
+        sll     $0,     32,     $25
+        ldq     $2,     56($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     24($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $23,    $23
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $385
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$385:
+        sll     $28,    32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $22,    $7,     $22
+        stq     $22,    80($16)
+        ldq     $4,     32($17)
+        ldq     $5,     56($18)
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $22
+        mulq    $7,     $5,     $2
+        addq    $1,     $23,    $23
+        addq    $0,     $22,    $0
+        cmpult  $0,     $22,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $389
+        sll     $21,    32,     $1
+        addq    $6,     $1,     $6
+$389:
+        sll     $0,     32,     $22
+        ldq     $1,     48($18)
+        addq    $2,     $22,    $2
+        bis     $2,     $2,     $7
+        ldq     $4,     40($17)
+        addq    $24,    $7,     $24
+        srl     $1,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $25
+        zapnot  $1,     15,     $5
+        mulq    $7,     $5,     $21
+        srl     $0,     32,     $1
+        cmpult  $2,     $22,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $22
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $5
+        bis     $31,    1,      $20
+        addq    $25,    $5,     $25
+        cmpult  $25,    $5,     $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $393
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$393:
+        sll     $25,    32,     $5
+        ldq     $2,     40($18)
+        addq    $21,    $5,     $21
+        bis     $21,    $21,    $7
+        ldq     $4,     48($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $25,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $21,    $5,     $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $397
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$397:
+        sll     $28,    32,     $25
+        ldq     $2,     32($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     56($17)
+        addq    $24,    $7,     $24
+        srl     $2,     32,     $8
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $21
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $22,    $22
+        addq    $21,    $25,    $21
+        cmpult  $21,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $401
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$401:
+        sll     $21,    32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $24,    $7,     $24
+        stq     $24,    88($16)
+        ldq     $4,     56($17)
+        ldq     $5,     40($18)
+        cmpult  $24,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $0
+        srl     $21,    32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $23,    $6,     $23
+        cmpult  $23,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $24
+        mulq    $7,     $5,     $5
+        addq    $1,     $22,    $22
+        addq    $0,     $24,    $0
+        cmpult  $0,     $24,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $405
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$405:
+        sll     $0,     32,     $24
+        ldq     $2,     48($18)
+        addq    $5,     $24,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     48($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $24,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $24
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $5
+        addq    $28,    $25,    $28
+        cmpult  $28,    $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $409
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$409:
+        sll     $28,    32,     $25
+        ldq     $2,     56($18)
+        addq    $5,     $25,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     40($17)
+        addq    $23,    $7,     $23
+        srl     $2,     32,     $8
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $25,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $1,     $24,    $24
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $413
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$413:
+        sll     $0,     32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $23,    $7,     $23
+        stq     $23,    96($16)
+        ldq     $4,     48($17)
+        ldq     $5,     56($18)
+        cmpult  $23,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $22,    $6,     $22
+        cmpult  $22,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $23
+        mulq    $7,     $5,     $5
+        addq    $1,     $24,    $24
+        addq    $28,    $23,    $28
+        cmpult  $28,    $23,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $417
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$417:
+        sll     $28,    32,     $23
+        ldq     $2,     48($18)
+        addq    $5,     $23,    $5
+        bis     $5,     $5,     $7
+        ldq     $4,     56($17)
+        addq    $22,    $7,     $22
+        srl     $2,     32,     $8
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        mulq    $8,     $7,     $0
+        srl     $28,    32,     $1
+        addq    $6,     $1,     $6
+        cmpult  $5,     $23,    $1
+        zapnot  $2,     15,     $5
+        addq    $1,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $23
+        srl     $4,     32,     $6
+        mulq    $5,     $6,     $25
+        mulq    $7,     $5,     $2
+        addq    $0,     $25,    $0
+        cmpult  $0,     $25,    $1
+        mulq    $6,     $8,     $6
+        beq     $1,     $421
+        sll     $20,    32,     $1
+        addq    $6,     $1,     $6
+$421:
+        sll     $0,     32,     $25
+        addq    $2,     $25,    $2
+        bis     $2,     $2,     $7
+        addq    $22,    $7,     $22
+        stq     $22,    104($16)
+        ldq     $4,     56($17)
+        ldq     $5,     56($18)
+        cmpult  $22,    $7,     $3
+        zapnot  $4,     15,     $7
+        srl     $5,     32,     $8
+        mulq    $8,     $7,     $28
+        srl     $0,     32,     $1
+        cmpult  $2,     $25,    $2
+        addq    $6,     $1,     $6
+        addq    $2,     $6,     $6
+        addq    $3,     $6,     $6
+        addq    $24,    $6,     $24
+        cmpult  $24,    $6,     $1
+        srl     $4,     32,     $6
+        zapnot  $5,     15,     $5
+        mulq    $5,     $6,     $22
+        mulq    $7,     $5,     $2
+        addq    $1,     $23,    $23
+        addq    $28,    $22,    $28
+        cmpult  $28,    $22,    $1
+        mulq    $6,     $8,     $3
+        beq     $1,     $425
+        sll     $20,    32,     $1
+        addq    $3,     $1,     $3
+$425:
+        sll     $28,    32,     $22
+        srl     $28,    32,     $1
+        addq    $2,     $22,    $2
+        addq    $3,     $1,     $3
+        bis     $2,     $2,     $7
+        addq    $24,    $7,     $24
+        cmpult  $7,     $22,    $1
+        cmpult  $24,    $7,     $2
+        addq    $1,     $3,     $6
+        addq    $2,     $6,     $6
+        stq     $24,    112($16)
+        addq    $23,    $6,     $23
+        stq     $23,    120($16)
+        ret     $31,    ($26),  1
         .end bn_mul_comba8
         .text
         .align 3
diff --git a/src/lib/libcrypto/bn/asm/mips3.s b/src/lib/libcrypto/bn/asm/mips3.s
index 191345d920..2df4dcd4b0 100644
--- a/src/lib/libcrypto/bn/asm/mips3.s
+++ b/src/lib/libcrypto/bn/asm/mips3.s
@@ -395,32 +395,32 @@ LEAF(bn_add_words)
 
 .L_bn_add_words_loop:
         ld      ta0,0(a2)
+        subu    a3,4
         ld      t1,8(a1)
-        ld      ta1,8(a2)
+        and     AT,a3,MINUS4
         ld      t2,16(a1)
-        ld      ta2,16(a2)
+        PTR_ADD a2,32
         ld      t3,24(a1)
-        ld      ta3,24(a2)
+        PTR_ADD a0,32
+        ld      ta1,-24(a2)
+        PTR_ADD a1,32
+        ld      ta2,-16(a2)
+        ld      ta3,-8(a2)
         daddu   ta0,t0
-        subu    a3,4
         sltu    t8,ta0,t0
         daddu   t0,ta0,v0
-        PTR_ADD a0,32
         sltu    v0,t0,ta0
         sd      t0,-32(a0)
         daddu   v0,t8
 
         daddu   ta1,t1
-        PTR_ADD a1,32
         sltu    t9,ta1,t1
         daddu   t1,ta1,v0
-        PTR_ADD a2,32
         sltu    v0,t1,ta1
         sd      t1,-24(a0)
         daddu   v0,t9
 
         daddu   ta2,t2
-        and     AT,a3,MINUS4
         sltu    t8,ta2,t2
         daddu   t2,ta2,v0
         sltu    v0,t2,ta2
@@ -495,25 +495,26 @@ LEAF(bn_sub_words)
 
 .L_bn_sub_words_loop:
         ld      ta0,0(a2)
+        subu    a3,4
         ld      t1,8(a1)
-        ld      ta1,8(a2)
+        and     AT,a3,MINUS4
         ld      t2,16(a1)
-        ld      ta2,16(a2)
+        PTR_ADD a2,32
         ld      t3,24(a1)
-        ld      ta3,24(a2)
+        PTR_ADD a0,32
+        ld      ta1,-24(a2)
+        PTR_ADD a1,32
+        ld      ta2,-16(a2)
+        ld      ta3,-8(a2)
         sltu    t8,t0,ta0
         dsubu   t0,ta0
-        subu    a3,4
         dsubu   ta0,t0,v0
-        and     AT,a3,MINUS4
-        sd      ta0,0(a0)
+        sd      ta0,-32(a0)
         MOVNZ   (t0,v0,t8)
 
         sltu    t9,t1,ta1
         dsubu   t1,ta1
-        PTR_ADD a0,32
         dsubu   ta1,t1,v0
-        PTR_ADD a1,32
         sd      ta1,-24(a0)
         MOVNZ   (t1,v0,t9)
 
@@ -521,7 +522,6 @@ LEAF(bn_sub_words)
         sltu    t8,t2,ta2
         dsubu   t2,ta2
         dsubu   ta2,t2,v0
-        PTR_ADD a2,32
         sd      ta2,-16(a0)
         MOVNZ   (t2,v0,t8)
 
@@ -574,6 +574,51 @@ END(bn_sub_words)
 
 #undef  MINUS4
 
+.align 5
+LEAF(bn_div_3_words)
+        .set    reorder
+        move    a3,a0           /* we know that bn_div_words doesn't
+                                 * touch a3, ta2, ta3 and preserves a2
+                                 * so that we can save two arguments
+                                 * and return address in registers
+                                 * instead of stack:-)
+                                 */
+        ld      a0,(a3)
+        move    ta2,a1
+        ld      a1,-8(a3)
+        move    ta3,ra
+        move    v1,zero
+        li      v0,-1
+        beq     a0,a2,.L_bn_div_3_words_skip_div
+        bal     bn_div_words
+        move    ra,ta3
+.L_bn_div_3_words_skip_div:
+        dmultu  ta2,v0
+        ld      t2,-16(a3)
+        move    ta0,zero
+        mfhi    t1
+        mflo    t0
+        sltu    t8,t1,v1
+.L_bn_div_3_words_inner_loop:
+        bnez    t8,.L_bn_div_3_words_inner_loop_done
+        sgeu    AT,t2,t0
+        seq     t9,t1,v1
+        and     AT,t9
+        sltu    t3,t0,ta2
+        daddu   v1,a2
+        dsubu   t1,t3
+        dsubu   t0,ta2
+        sltu    t8,t1,v1
+        sltu    ta0,v1,a2
+        or      t8,ta0
+        .set    noreorder
+        beqzl   AT,.L_bn_div_3_words_inner_loop
+        dsubu   v0,1
+        .set    reorder
+.L_bn_div_3_words_inner_loop_done:
+        jr      ra
+END(bn_div_3_words)
+
 .align  5
 LEAF(bn_div_words)
         .set    noreorder
@@ -633,16 +678,16 @@ LEAF(bn_div_words)
         seq     t8,HH,t1
         sltu    AT,HH,t1
         and     t2,t8
+        sltu    v0,t0,a2
         or      AT,t2
         .set    noreorder
         beqz    AT,.L_bn_div_words_inner_loop1_done
-        sltu    t2,t0,a2
-        .set    reorder
-        dsubu   QT,1
+        dsubu   t1,v0
         dsubu   t0,a2
-        dsubu   t1,t2
         b       .L_bn_div_words_inner_loop1
-.L_bn_div_words_inner_loop1_done:       
+        dsubu   QT,1
+        .set    reorder
+.L_bn_div_words_inner_loop1_done:
 
         dsll    a1,32
         dsubu   a0,t3,t0
@@ -655,6 +700,7 @@ LEAF(bn_div_words)
         ddivu   zero,a0,DH
         mflo    QT
 .L_bn_div_words_skip_div2:
+#undef  DH
         dmultu  a2,QT
         dsll    t3,a0,32
         dsrl    AT,a1,32
@@ -666,69 +712,26 @@ LEAF(bn_div_words)
         seq     t8,HH,t1
         sltu    AT,HH,t1
         and     t2,t8
+        sltu    v1,t0,a2
         or      AT,t2
         .set    noreorder
         beqz    AT,.L_bn_div_words_inner_loop2_done
-        sltu    t2,t0,a2
-        .set    reorder
-        dsubu   QT,1
+        dsubu   t1,v1
         dsubu   t0,a2
-        dsubu   t1,t2
         b       .L_bn_div_words_inner_loop2
+        dsubu   QT,1
+        .set    reorder
 .L_bn_div_words_inner_loop2_done:       
+#undef  HH
 
         dsubu   a0,t3,t0
         or      v0,QT
         dsrl    v1,a0,t9        /* v1 contains remainder if anybody wants it */
         dsrl    a2,t9           /* restore a2 */
         jr      ra
-#undef  HH
-#undef  DH
 #undef  QT
 END(bn_div_words)
 
-.align 5
-LEAF(bn_div_3_words)
-        .set    reorder
-        move    a3,a0           /* we know that bn_div_words doesn't
-                                 * touch a3, ta2, ta3 and preserves a2
-                                 * so that we can save two arguments
-                                 * and return address in registers
-                                 * instead of stack:-)
-                                 */
-        ld      a0,(a3)
-        move    ta2,a2
-        move    a2,a1
-        ld      a1,-8(a3)
-        move    ta3,ra
-        move    v1,zero
-        li      v0,-1
-        beq     a0,a2,.L_bn_div_3_words_skip_div
-        jal     bn_div_words
-        move    ra,ta3
-.L_bn_div_3_words_skip_div:
-        dmultu  ta2,v0
-        ld      t2,-16(a3)
-        mflo    t0
-        mfhi    t1
-.L_bn_div_3_words_inner_loop:
-        sgeu    AT,t2,t0
-        seq     t9,t1,v1
-        sltu    t8,t1,v1
-        and     AT,t9
-        or      AT,t8
-        bnez    AT,.L_bn_div_3_words_inner_loop_done
-        daddu   v1,a2
-        sltu    t3,t0,ta2
-        sltu    AT,v1,a2
-        dsubu   v0,1
-        dsubu   t0,ta2
-        dsubu   t1,t3
-        beqz    AT,.L_bn_div_3_words_inner_loop
-.L_bn_div_3_words_inner_loop_done:
-        jr      ra
-END(bn_div_3_words)
-
 #define a_0     t0
 #define a_1     t1
 #define a_2     t2
diff --git a/src/lib/libcrypto/bn/bn.h b/src/lib/libcrypto/bn/bn.h
index f935e1ca79..d8822610df 100644
--- a/src/lib/libcrypto/bn/bn.h
+++ b/src/lib/libcrypto/bn/bn.h
@@ -83,12 +83,12 @@ extern "C" {
  * The reason for this flag is that when the particular C compiler
  * library routine is used, and the library is linked with a different
  * compiler, the library is missing.  This mostly happens when the
- * library is built with gcc and then linked using nornal cc.  This would
- * be a common occurance because gcc normally produces code that is
+ * library is built with gcc and then linked using normal cc.  This would
+ * be a common occurrence because gcc normally produces code that is
  * 2 times faster than system compilers for the big number stuff.
  * For machines with only one compiler (or shared libraries), this should
  * be on.  Again this in only really a problem on machines
- * using "long long's", are 32bit, and are not using my assember code. */
+ * using "long long's", are 32bit, and are not using my assembler code. */
 #if defined(MSDOS) || defined(WINDOWS) || defined(linux)
 #define BN_DIV2W
 #endif
@@ -118,8 +118,8 @@ extern "C" {
 
 /* This is where the long long data type is 64 bits, but long is 32.
  * For machines where there are 64bit registers, this is the mode to use.
- * IRIX, on R4000 and above should use this mode, along with the relevent
- * assember code :-).  Do NOT define BN_LLONG.
+ * IRIX, on R4000 and above should use this mode, along with the relevant
+ * assembler code :-).  Do NOT define BN_LLONG.
  */
 #ifdef SIXTY_FOUR_BIT
 #undef BN_LLONG
@@ -240,11 +240,15 @@ typedef struct bignum_st
 
 /* Used for temp variables */
 #define BN_CTX_NUM      12
+#define BN_CTX_NUM_POS  12
 typedef struct bignum_ctx
         {
         int tos;
-        BIGNUM bn[BN_CTX_NUM+1];
+        BIGNUM bn[BN_CTX_NUM];
         int flags;
+        int depth;
+        int pos[BN_CTX_NUM_POS];
+        int too_many;
         } BN_CTX;
 
 typedef struct bn_blinding_st
@@ -257,16 +261,15 @@ typedef struct bn_blinding_st
 
 /* Used for montgomery multiplication */
 typedef struct bn_mont_ctx_st
-        {
-        int use_word;   /* 0 for word form, 1 for long form */
-        int ri;         /* number of bits in R */
-        BIGNUM RR;     /* used to convert to montgomery form */
-        BIGNUM N;      /* The modulus */
-        BIGNUM Ni;     /* The inverse of N */
-        BN_ULONG n0;    /* word form of inverse, normally only one of
-                         * Ni or n0 is defined */
+        {
+        int ri;        /* number of bits in R */
+        BIGNUM RR;     /* used to convert to montgomery form */
+        BIGNUM N;      /* The modulus */
+        BIGNUM Ni;     /* R*(1/R mod N) - N*Ni = 1
+                        * (Ni is only stored for bignum algorithm) */
+        BN_ULONG n0;   /* least significant word of Ni */
         int flags;
-        } BN_MONT_CTX;
+        } BN_MONT_CTX;
 
 /* Used for reciprocal division/mod functions
  * It cannot be shared between threads
@@ -283,7 +286,26 @@ typedef struct bn_recp_ctx_st
 #define BN_to_montgomery(r,a,mont,ctx)  BN_mod_mul_montgomery(\
         r,a,&((mont)->RR),(mont),ctx)
 
-#define BN_prime_checks         (5)
+#define BN_prime_checks 0 /* default: select number of iterations
+                             based on the size of the number */
+
+/* number of Miller-Rabin iterations for an error rate  of less than 2^-80
+ * for random 'b'-bit input, b >= 100 (taken from table 4.4 in the Handbook
+ * of Applied Cryptography [Menezes, van Oorschot, Vanstone; CRC Press 1996];
+ * original paper: Damgaard, Landrock, Pomerance: Average case error estimates
+ * for the strong probable prime test. -- Math. Comp. 61 (1993) 177-194) */
+#define BN_prime_checks_for_size(b) ((b) >= 1300 ?  2 : \
+                                (b) >=  850 ?  3 : \
+                                (b) >=  650 ?  4 : \
+                                (b) >=  550 ?  5 : \
+                                (b) >=  450 ?  6 : \
+                                (b) >=  400 ?  7 : \
+                                (b) >=  350 ?  8 : \
+                                (b) >=  300 ?  9 : \
+                                (b) >=  250 ? 12 : \
+                                (b) >=  200 ? 15 : \
+                                (b) >=  150 ? 18 : \
+                                /* b >= 100 */ 27)
 
 #define BN_num_bytes(a) ((BN_num_bits(a)+7)/8)
 #define BN_is_word(a,w) (((a)->top == 1) && ((a)->d[0] == (BN_ULONG)(w)))
@@ -296,26 +318,16 @@ typedef struct bn_recp_ctx_st
 /*#define BN_ascii2bn(a)        BN_hex2bn(a) */
 /*#define BN_bn2ascii(a)        BN_bn2hex(a) */
 
-#define bn_expand(n,b) ((((((b+BN_BITS2-1))/BN_BITS2)) <= (n)->max)?\
-        (n):bn_expand2((n),(b)/BN_BITS2+1))
-#define bn_wexpand(n,b) (((b) <= (n)->max)?(n):bn_expand2((n),(b)))
-
-#define bn_fix_top(a) \
-        { \
-        BN_ULONG *ftl; \
-        if ((a)->top > 0) \
-                { \
-                for (ftl= &((a)->d[(a)->top-1]); (a)->top > 0; (a)->top--) \
-                if (*(ftl--)) break; \
-                } \
-        }
-
 BIGNUM *BN_value_one(void);
 char *  BN_options(void);
 BN_CTX *BN_CTX_new(void);
 void    BN_CTX_init(BN_CTX *c);
 void    BN_CTX_free(BN_CTX *c);
+void    BN_CTX_start(BN_CTX *ctx);
+BIGNUM *BN_CTX_get(BN_CTX *ctx);
+void    BN_CTX_end(BN_CTX *ctx);
 int     BN_rand(BIGNUM *rnd, int bits, int top,int bottom);
+int     BN_pseudo_rand(BIGNUM *rnd, int bits, int top,int bottom);
 int     BN_num_bits(const BIGNUM *a);
 int     BN_num_bits_word(BN_ULONG);
 BIGNUM *BN_new(void);
@@ -329,13 +341,13 @@ int	BN_bn2mpi(const BIGNUM *a, unsigned char *to);
 int     BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
 int     BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
 int     BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
-int     BN_add(BIGNUM *r, BIGNUM *a, BIGNUM *b);
+int     BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
 int     BN_mod(BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
 int     BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
                BN_CTX *ctx);
-int     BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b,BN_CTX *ctx);
+int     BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx);
 int     BN_sqr(BIGNUM *r, BIGNUM *a,BN_CTX *ctx);
-BN_ULONG BN_mod_word(BIGNUM *a, BN_ULONG w);
+BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w);
 BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w);
 int     BN_mul_word(BIGNUM *a, BN_ULONG w);
 int     BN_add_word(BIGNUM *a, BN_ULONG w);
@@ -358,19 +370,18 @@ int	BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p,
         BIGNUM *m,BN_CTX *ctx);
 int     BN_mask_bits(BIGNUM *a,int n);
 int     BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx);
-#ifndef WIN16
-int     BN_print_fp(FILE *fp, BIGNUM *a);
+#ifndef NO_FP_API
+int     BN_print_fp(FILE *fp, const BIGNUM *a);
 #endif
 #ifdef HEADER_BIO_H
 int     BN_print(BIO *fp, const BIGNUM *a);
 #else
-int     BN_print(char *fp, const BIGNUM *a);
+int     BN_print(void *fp, const BIGNUM *a);
 #endif
 int     BN_reciprocal(BIGNUM *r, BIGNUM *m, int len, BN_CTX *ctx);
 int     BN_rshift(BIGNUM *r, BIGNUM *a, int n);
 int     BN_rshift1(BIGNUM *r, BIGNUM *a);
 void    BN_clear(BIGNUM *a);
-BIGNUM *bn_expand2(BIGNUM *b, int bits);
 BIGNUM *BN_dup(const BIGNUM *a);
 int     BN_ucmp(const BIGNUM *a, const BIGNUM *b);
 int     BN_set_bit(BIGNUM *a, int n);
@@ -381,19 +392,16 @@ int 	BN_hex2bn(BIGNUM **a, const char *str);
 int     BN_dec2bn(BIGNUM **a, const char *str);
 int     BN_gcd(BIGNUM *r,BIGNUM *in_a,BIGNUM *in_b,BN_CTX *ctx);
 BIGNUM *BN_mod_inverse(BIGNUM *ret,BIGNUM *a, const BIGNUM *n,BN_CTX *ctx);
-BIGNUM *BN_generate_prime(BIGNUM *ret,int bits,int strong,BIGNUM *add,
+BIGNUM *BN_generate_prime(BIGNUM *ret,int bits,int safe,BIGNUM *add,
                 BIGNUM *rem,void (*callback)(int,int,void *),void *cb_arg);
-int     BN_is_prime(BIGNUM *p,int nchecks,void (*callback)(int,int,void *),
+int     BN_is_prime(const BIGNUM *p,int nchecks,
+                void (*callback)(int,int,void *),
                 BN_CTX *ctx,void *cb_arg);
+int     BN_is_prime_fasttest(const BIGNUM *p,int nchecks,
+                void (*callback)(int,int,void *),BN_CTX *ctx,void *cb_arg,
+                int do_trial_division);
 void    ERR_load_BN_strings(void );
 
-BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w);
-BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w);
-void     bn_sqr_words(BN_ULONG *rp, BN_ULONG *ap, int num);
-BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d);
-BN_ULONG bn_add_words(BN_ULONG *rp, BN_ULONG *ap, BN_ULONG *bp,int num);
-BN_ULONG bn_sub_words(BN_ULONG *rp, BN_ULONG *ap, BN_ULONG *bp,int num);
-
 BN_MONT_CTX *BN_MONT_CTX_new(void );
 void BN_MONT_CTX_init(BN_MONT_CTX *ctx);
 int BN_mod_mul_montgomery(BIGNUM *r,BIGNUM *a,BIGNUM *b,BN_MONT_CTX *mont,
@@ -423,6 +431,39 @@ int	BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 int     BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m,
                 BN_RECP_CTX *recp, BN_CTX *ctx);
 
+/* library internal functions */
+
+#define bn_expand(a,bits) ((((((bits+BN_BITS2-1))/BN_BITS2)) <= (a)->max)?\
+        (a):bn_expand2((a),(bits)/BN_BITS2+1))
+#define bn_wexpand(a,words) (((words) <= (a)->max)?(a):bn_expand2((a),(words)))
+BIGNUM *bn_expand2(BIGNUM *a, int words);
+
+#define bn_fix_top(a) \
+        { \
+        BN_ULONG *ftl; \
+        if ((a)->top > 0) \
+                { \
+                for (ftl= &((a)->d[(a)->top-1]); (a)->top > 0; (a)->top--) \
+                if (*(ftl--)) break; \
+                } \
+        }
+
+BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w);
+BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w);
+void     bn_sqr_words(BN_ULONG *rp, BN_ULONG *ap, int num);
+BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d);
+BN_ULONG bn_add_words(BN_ULONG *rp, BN_ULONG *ap, BN_ULONG *bp,int num);
+BN_ULONG bn_sub_words(BN_ULONG *rp, BN_ULONG *ap, BN_ULONG *bp,int num);
+
+#ifdef BN_DEBUG
+  void bn_dump1(FILE *o, const char *a, BN_ULONG *b,int n);
+# define bn_print(a) {fprintf(stderr, #a "="); BN_print_fp(stderr,a); \
+   fprintf(stderr,"\n");}
+# define bn_dump(a,n) bn_dump1(stderr,#a,a,n);
+#else
+# define bn_print(a)
+# define bn_dump(a,b)
+#endif
 
 /* BEGIN ERROR CODES */
 /* The following lines are auto generated by the script mkerr.pl. Any changes
@@ -438,6 +479,7 @@ int	BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m,
 #define BN_F_BN_BLINDING_UPDATE                          103
 #define BN_F_BN_BN2DEC                                   104
 #define BN_F_BN_BN2HEX                                   105
+#define BN_F_BN_CTX_GET                                  116
 #define BN_F_BN_CTX_NEW                                  106
 #define BN_F_BN_DIV                                      107
 #define BN_F_BN_EXPAND2                                  108
@@ -459,6 +501,7 @@ int	BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m,
 #define BN_R_INVALID_LENGTH                              106
 #define BN_R_NOT_INITIALIZED                             107
 #define BN_R_NO_INVERSE                                  108
+#define BN_R_TOO_MANY_TEMPORARY_VARIABLES                109
 
 #ifdef  __cplusplus
 }
diff --git a/src/lib/libcrypto/bn/bn_add.c b/src/lib/libcrypto/bn/bn_add.c
index c5ab066c9e..5d24691233 100644
--- a/src/lib/libcrypto/bn/bn_add.c
+++ b/src/lib/libcrypto/bn/bn_add.c
@@ -61,9 +61,9 @@
 #include "bn_lcl.h"
 
 /* r can == a or b */
-int BN_add(BIGNUM *r, BIGNUM *a, BIGNUM *b)
+int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
         {
-        BIGNUM *tmp;
+        const BIGNUM *tmp;
 
         bn_check_top(a);
         bn_check_top(b);
diff --git a/src/lib/libcrypto/bn/bn_asm.c b/src/lib/libcrypto/bn/bn_asm.c
index 4d3da16a0c..3329cc18e6 100644
--- a/src/lib/libcrypto/bn/bn_asm.c
+++ b/src/lib/libcrypto/bn/bn_asm.c
@@ -56,31 +56,38 @@
  * [including the GNU Public Licence.]
  */
 
+#ifndef BN_DEBUG
+# undef NDEBUG /* avoid conflicting definitions */
+# define NDEBUG
+#endif
+
 #include <stdio.h>
+#include <assert.h>
 #include "cryptlib.h"
 #include "bn_lcl.h"
 
-#ifdef BN_LLONG 
+#if defined(BN_LLONG) || defined(BN_UMULT_HIGH)
 
 BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
         {
         BN_ULONG c1=0;
 
-        bn_check_num(num);
+        assert(num >= 0);
         if (num <= 0) return(c1);
 
-        for (;;)
+        while (num&~3)
                 {
                 mul_add(rp[0],ap[0],w,c1);
-                if (--num == 0) break;
                 mul_add(rp[1],ap[1],w,c1);
-                if (--num == 0) break;
                 mul_add(rp[2],ap[2],w,c1);
-                if (--num == 0) break;
                 mul_add(rp[3],ap[3],w,c1);
-                if (--num == 0) break;
-                ap+=4;
-                rp+=4;
+                ap+=4; rp+=4; num-=4;
+                }
+        if (num)
+                {
+                mul_add(rp[0],ap[0],w,c1); if (--num==0) return c1;
+                mul_add(rp[1],ap[1],w,c1); if (--num==0) return c1;
+                mul_add(rp[2],ap[2],w,c1); return c1;
                 }
         
         return(c1);
@@ -90,63 +97,54 @@ BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
         {
         BN_ULONG c1=0;
 
-        bn_check_num(num);
+        assert(num >= 0);
         if (num <= 0) return(c1);
 
-        /* for (;;) */
-        while (1) /* circumvent egcs-1.1.2 bug */
+        while (num&~3)
                 {
                 mul(rp[0],ap[0],w,c1);
-                if (--num == 0) break;
                 mul(rp[1],ap[1],w,c1);
-                if (--num == 0) break;
                 mul(rp[2],ap[2],w,c1);
-                if (--num == 0) break;
                 mul(rp[3],ap[3],w,c1);
-                if (--num == 0) break;
-                ap+=4;
-                rp+=4;
+                ap+=4; rp+=4; num-=4;
+                }
+        if (num)
+                {
+                mul(rp[0],ap[0],w,c1); if (--num == 0) return c1;
+                mul(rp[1],ap[1],w,c1); if (--num == 0) return c1;
+                mul(rp[2],ap[2],w,c1);
                 }
         return(c1);
         } 
 
 void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n)
         {
-        bn_check_num(n);
+        assert(n >= 0);
         if (n <= 0) return;
-        for (;;)
+        while (n&~3)
                 {
-                BN_ULLONG t;
-
-                t=(BN_ULLONG)(a[0])*(a[0]);
-                r[0]=Lw(t); r[1]=Hw(t);
-                if (--n == 0) break;
-
-                t=(BN_ULLONG)(a[1])*(a[1]);
-                r[2]=Lw(t); r[3]=Hw(t);
-                if (--n == 0) break;
-
-                t=(BN_ULLONG)(a[2])*(a[2]);
-                r[4]=Lw(t); r[5]=Hw(t);
-                if (--n == 0) break;
-
-                t=(BN_ULLONG)(a[3])*(a[3]);
-                r[6]=Lw(t); r[7]=Hw(t);
-                if (--n == 0) break;
-
-                a+=4;
-                r+=8;
+                sqr(r[0],r[1],a[0]);
+                sqr(r[2],r[3],a[1]);
+                sqr(r[4],r[5],a[2]);
+                sqr(r[6],r[7],a[3]);
+                a+=4; r+=8; n-=4;
+                }
+        if (n)
+                {
+                sqr(r[0],r[1],a[0]); if (--n == 0) return;
+                sqr(r[2],r[3],a[1]); if (--n == 0) return;
+                sqr(r[4],r[5],a[2]);
                 }
         }
 
-#else
+#else /* !(defined(BN_LLONG) || defined(BN_UMULT_HIGH)) */
 
 BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
         {
         BN_ULONG c=0;
         BN_ULONG bl,bh;
 
-        bn_check_num(num);
+        assert(num >= 0);
         if (num <= 0) return((BN_ULONG)0);
 
         bl=LBITS(w);
@@ -173,7 +171,7 @@ BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
         BN_ULONG carry=0;
         BN_ULONG bl,bh;
 
-        bn_check_num(num);
+        assert(num >= 0);
         if (num <= 0) return((BN_ULONG)0);
 
         bl=LBITS(w);
@@ -197,7 +195,7 @@ BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w)
 
 void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n)
         {
-        bn_check_num(n);
+        assert(n >= 0);
         if (n <= 0) return;
         for (;;)
                 {
@@ -218,7 +216,7 @@ void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n)
                 }
         }
 
-#endif
+#endif /* !(defined(BN_LLONG) || defined(BN_UMULT_HIGH)) */
 
 #if defined(BN_LLONG) && defined(BN_DIV2W)
 
@@ -300,14 +298,14 @@ BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d)
         ret|=q;
         return(ret);
         }
-#endif
+#endif /* !defined(BN_LLONG) && defined(BN_DIV2W) */
 
 #ifdef BN_LLONG
 BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
         {
         BN_ULLONG ll=0;
 
-        bn_check_num(n);
+        assert(n >= 0);
         if (n <= 0) return((BN_ULONG)0);
 
         for (;;)
@@ -338,12 +336,12 @@ BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
                 }
         return((BN_ULONG)ll);
         }
-#else
+#else /* !BN_LLONG */
 BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
         {
         BN_ULONG c,l,t;
 
-        bn_check_num(n);
+        assert(n >= 0);
         if (n <= 0) return((BN_ULONG)0);
 
         c=0;
@@ -387,14 +385,14 @@ BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
                 }
         return((BN_ULONG)c);
         }
-#endif
+#endif /* !BN_LLONG */
 
 BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
         {
         BN_ULONG t1,t2;
         int c=0;
 
-        bn_check_num(n);
+        assert(n >= 0);
         if (n <= 0) return((BN_ULONG)0);
 
         for (;;)
@@ -433,6 +431,11 @@ BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
 #undef bn_sqr_comba8
 #undef bn_sqr_comba4
 
+/* mul_add_c(a,b,c0,c1,c2)  -- c+=a*b for three word number c=(c2,c1,c0) */
+/* mul_add_c2(a,b,c0,c1,c2) -- c+=2*a*b for three word number c=(c2,c1,c0) */
+/* sqr_add_c(a,i,c0,c1,c2)  -- c+=a[i]^2 for three word number c=(c2,c1,c0) */
+/* sqr_add_c2(a,i,c0,c1,c2) -- c+=2*a[i]*a[j] for three word number c=(c2,c1,c0) */
+
 #ifdef BN_LLONG
 #define mul_add_c(a,b,c0,c1,c2) \
         t=(BN_ULLONG)a*b; \
@@ -460,7 +463,39 @@ BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
 
 #define sqr_add_c2(a,i,j,c0,c1,c2) \
         mul_add_c2((a)[i],(a)[j],c0,c1,c2)
-#else
+
+#elif defined(BN_UMULT_HIGH)
+
+#define mul_add_c(a,b,c0,c1,c2) {       \
+        BN_ULONG ta=(a),tb=(b);         \
+        t1 = ta * tb;                   \
+        t2 = BN_UMULT_HIGH(ta,tb);      \
+        c0 += t1; t2 += (c0<t1)?1:0;    \
+        c1 += t2; c2 += (c1<t2)?1:0;    \
+        }
+
+#define mul_add_c2(a,b,c0,c1,c2) {      \
+        BN_ULONG ta=(a),tb=(b),t0;      \
+        t1 = BN_UMULT_HIGH(ta,tb);      \
+        t0 = ta * tb;                   \
+        t2 = t1+t1; c2 += (t2<t1)?1:0;  \
+        t1 = t0+t0; t2 += (t1<t0)?1:0;  \
+        c0 += t1; t2 += (c0<t1)?1:0;    \
+        c1 += t2; c2 += (c1<t2)?1:0;    \
+        }
+
+#define sqr_add_c(a,i,c0,c1,c2) {       \
+        BN_ULONG ta=(a)[i];             \
+        t1 = ta * ta;                   \
+        t2 = BN_UMULT_HIGH(ta,ta);      \
+        c0 += t1; t2 += (c0<t1)?1:0;    \
+        c1 += t2; c2 += (c1<t2)?1:0;    \
+        }
+
+#define sqr_add_c2(a,i,j,c0,c1,c2)      \
+        mul_add_c2((a)[i],(a)[j],c0,c1,c2)
+
+#else /* !BN_LLONG */
 #define mul_add_c(a,b,c0,c1,c2) \
         t1=LBITS(a); t2=HBITS(a); \
         bl=LBITS(b); bh=HBITS(b); \
@@ -487,7 +522,7 @@ BN_ULONG bn_sub_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
 
 #define sqr_add_c2(a,i,j,c0,c1,c2) \
         mul_add_c2((a)[i],(a)[j],c0,c1,c2)
-#endif
+#endif /* !BN_LLONG */
 
 void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
         {
@@ -762,7 +797,7 @@ void bn_sqr_comba4(BN_ULONG *r, BN_ULONG *a)
         r[6]=c1;
         r[7]=c2;
         }
-#else
+#else /* !BN_MUL_COMBA */
 
 /* hmm... is it faster just to do a multiply? */
 #undef bn_sqr_comba4
@@ -799,4 +834,4 @@ void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
         r[15]=bn_mul_add_words(&(r[7]),a,8,b[7]);
         }
 
-#endif /* BN_COMBA */
+#endif /* !BN_MUL_COMBA */
diff --git a/src/lib/libcrypto/bn/bn_comba.c b/src/lib/libcrypto/bn/bn_comba.c
index 7ad09b4a6d..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/bn_comba.c
+++ b/src/lib/libcrypto/bn/bn_comba.c
@@ -1,345 +0,0 @@
-/* crypto/bn/bn_comba.c */
-#include <stdio.h>
-#include "bn_lcl.h"
-/* Auto generated from crypto/bn/comba.pl
- */
-
-#undef bn_mul_comba8
-#undef bn_mul_comba4
-#undef bn_sqr_comba8
-#undef bn_sqr_comba4
-
-#ifdef BN_LLONG
-#define mul_add_c(a,b,c0,c1,c2) \
-        t=(BN_ULLONG)a*b; \
-        t1=(BN_ULONG)Lw(t); \
-        t2=(BN_ULONG)Hw(t); \
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define mul_add_c2(a,b,c0,c1,c2) \
-        t=(BN_ULLONG)a*b; \
-        tt=(t+t)&BN_MASK; \
-        if (tt < t) c2++; \
-        t1=(BN_ULONG)Lw(tt); \
-        t2=(BN_ULONG)Hw(tt); \
-        c0=(c0+t1)&BN_MASK2;  \
-        if ((c0 < t1) && (((++t2)&BN_MASK2) == 0)) c2++; \
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c(a,i,c0,c1,c2) \
-        t=(BN_ULLONG)a[i]*a[i]; \
-        t1=(BN_ULONG)Lw(t); \
-        t2=(BN_ULONG)Hw(t); \
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c2(a,i,j,c0,c1,c2) \
-        mul_add_c2((a)[i],(a)[j],c0,c1,c2)
-#else
-#define mul_add_c(a,b,c0,c1,c2) \
-        t1=LBITS(a); t2=HBITS(a); \
-        bl=LBITS(b); bh=HBITS(b); \
-        mul64(t1,t2,bl,bh); \
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define mul_add_c2(a,b,c0,c1,c2) \
-        t1=LBITS(a); t2=HBITS(a); \
-        bl=LBITS(b); bh=HBITS(b); \
-        mul64(t1,t2,bl,bh); \
-        if (t2 & BN_TBIT) c2++; \
-        t2=(t2+t2)&BN_MASK2; \
-        if (t1 & BN_TBIT) t2++; \
-        t1=(t1+t1)&BN_MASK2; \
-        c0=(c0+t1)&BN_MASK2;  \
-        if ((c0 < t1) && (((++t2)&BN_MASK2) == 0)) c2++; \
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c(a,i,c0,c1,c2) \
-        sqr64(t1,t2,(a)[i]); \
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c2(a,i,j,c0,c1,c2) \
-        mul_add_c2((a)[i],(a)[j],c0,c1,c2)
-#endif
-
-void bn_mul_comba88(BN_ULONG *r,BN_ULONG *a,BN_ULONG *b);
-void bn_mul_comba44(BN_ULONG *r,BN_ULONG *a,BN_ULONG *b);
-void bn_sqr_comba88(BN_ULONG *r,BN_ULONG *a);
-void bn_sqr_comba44(BN_ULONG *r,BN_ULONG *a);
-
-void bn_mul_comba88(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-        c1=0;
-        c2=0;
-        c3=0;
-        mul_add_c(a[0],b[0],c1,c2,c3);
-        r[0]=c1;
-        c1=0;
-        mul_add_c(a[0],b[1],c2,c3,c1);
-        mul_add_c(a[1],b[0],c2,c3,c1);
-        r[1]=c2;
-        c2=0;
-        mul_add_c(a[2],b[0],c3,c1,c2);
-        mul_add_c(a[1],b[1],c3,c1,c2);
-        mul_add_c(a[0],b[2],c3,c1,c2);
-        r[2]=c3;
-        c3=0;
-        mul_add_c(a[0],b[3],c1,c2,c3);
-        mul_add_c(a[1],b[2],c1,c2,c3);
-        mul_add_c(a[2],b[1],c1,c2,c3);
-        mul_add_c(a[3],b[0],c1,c2,c3);
-        r[3]=c1;
-        c1=0;
-        mul_add_c(a[4],b[0],c2,c3,c1);
-        mul_add_c(a[3],b[1],c2,c3,c1);
-        mul_add_c(a[2],b[2],c2,c3,c1);
-        mul_add_c(a[1],b[3],c2,c3,c1);
-        mul_add_c(a[0],b[4],c2,c3,c1);
-        r[4]=c2;
-        c2=0;
-        mul_add_c(a[0],b[5],c3,c1,c2);
-        mul_add_c(a[1],b[4],c3,c1,c2);
-        mul_add_c(a[2],b[3],c3,c1,c2);
-        mul_add_c(a[3],b[2],c3,c1,c2);
-        mul_add_c(a[4],b[1],c3,c1,c2);
-        mul_add_c(a[5],b[0],c3,c1,c2);
-        r[5]=c3;
-        c3=0;
-        mul_add_c(a[6],b[0],c1,c2,c3);
-        mul_add_c(a[5],b[1],c1,c2,c3);
-        mul_add_c(a[4],b[2],c1,c2,c3);
-        mul_add_c(a[3],b[3],c1,c2,c3);
-        mul_add_c(a[2],b[4],c1,c2,c3);
-        mul_add_c(a[1],b[5],c1,c2,c3);
-        mul_add_c(a[0],b[6],c1,c2,c3);
-        r[6]=c1;
-        c1=0;
-        mul_add_c(a[0],b[7],c2,c3,c1);
-        mul_add_c(a[1],b[6],c2,c3,c1);
-        mul_add_c(a[2],b[5],c2,c3,c1);
-        mul_add_c(a[3],b[4],c2,c3,c1);
-        mul_add_c(a[4],b[3],c2,c3,c1);
-        mul_add_c(a[5],b[2],c2,c3,c1);
-        mul_add_c(a[6],b[1],c2,c3,c1);
-        mul_add_c(a[7],b[0],c2,c3,c1);
-        r[7]=c2;
-        c2=0;
-        mul_add_c(a[7],b[1],c3,c1,c2);
-        mul_add_c(a[6],b[2],c3,c1,c2);
-        mul_add_c(a[5],b[3],c3,c1,c2);
-        mul_add_c(a[4],b[4],c3,c1,c2);
-        mul_add_c(a[3],b[5],c3,c1,c2);
-        mul_add_c(a[2],b[6],c3,c1,c2);
-        mul_add_c(a[1],b[7],c3,c1,c2);
-        r[8]=c3;
-        c3=0;
-        mul_add_c(a[2],b[7],c1,c2,c3);
-        mul_add_c(a[3],b[6],c1,c2,c3);
-        mul_add_c(a[4],b[5],c1,c2,c3);
-        mul_add_c(a[5],b[4],c1,c2,c3);
-        mul_add_c(a[6],b[3],c1,c2,c3);
-        mul_add_c(a[7],b[2],c1,c2,c3);
-        r[9]=c1;
-        c1=0;
-        mul_add_c(a[7],b[3],c2,c3,c1);
-        mul_add_c(a[6],b[4],c2,c3,c1);
-        mul_add_c(a[5],b[5],c2,c3,c1);
-        mul_add_c(a[4],b[6],c2,c3,c1);
-        mul_add_c(a[3],b[7],c2,c3,c1);
-        r[10]=c2;
-        c2=0;
-        mul_add_c(a[4],b[7],c3,c1,c2);
-        mul_add_c(a[5],b[6],c3,c1,c2);
-        mul_add_c(a[6],b[5],c3,c1,c2);
-        mul_add_c(a[7],b[4],c3,c1,c2);
-        r[11]=c3;
-        c3=0;
-        mul_add_c(a[7],b[5],c1,c2,c3);
-        mul_add_c(a[6],b[6],c1,c2,c3);
-        mul_add_c(a[5],b[7],c1,c2,c3);
-        r[12]=c1;
-        c1=0;
-        mul_add_c(a[6],b[7],c2,c3,c1);
-        mul_add_c(a[7],b[6],c2,c3,c1);
-        r[13]=c2;
-        c2=0;
-        mul_add_c(a[7],b[7],c3,c1,c2);
-        r[14]=c3;
-        r[15]=c1;
-        }
-
-void bn_mul_comba44(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b)
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-        c1=0;
-        c2=0;
-        c3=0;
-        mul_add_c(a[0],b[0],c1,c2,c3);
-        r[0]=c1;
-        c1=0;
-        mul_add_c(a[0],b[1],c2,c3,c1);
-        mul_add_c(a[1],b[0],c2,c3,c1);
-        r[1]=c2;
-        c2=0;
-        mul_add_c(a[2],b[0],c3,c1,c2);
-        mul_add_c(a[1],b[1],c3,c1,c2);
-        mul_add_c(a[0],b[2],c3,c1,c2);
-        r[2]=c3;
-        c3=0;
-        mul_add_c(a[0],b[3],c1,c2,c3);
-        mul_add_c(a[1],b[2],c1,c2,c3);
-        mul_add_c(a[2],b[1],c1,c2,c3);
-        mul_add_c(a[3],b[0],c1,c2,c3);
-        r[3]=c1;
-        c1=0;
-        mul_add_c(a[3],b[1],c2,c3,c1);
-        mul_add_c(a[2],b[2],c2,c3,c1);
-        mul_add_c(a[1],b[3],c2,c3,c1);
-        r[4]=c2;
-        c2=0;
-        mul_add_c(a[2],b[3],c3,c1,c2);
-        mul_add_c(a[3],b[2],c3,c1,c2);
-        r[5]=c3;
-        c3=0;
-        mul_add_c(a[3],b[3],c1,c2,c3);
-        r[6]=c1;
-        r[7]=c2;
-        }
-
-void bn_sqr_comba88(BN_ULONG *r, BN_ULONG *a)
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t,tt;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-        c1=0;
-        c2=0;
-        c3=0;
-        sqr_add_c(a,0,c1,c2,c3);
-        r[0]=c1;
-        c1=0;
-        sqr_add_c2(a,1,0,c2,c3,c1);
-        r[1]=c2;
-        c2=0;
-        sqr_add_c(a,1,c3,c1,c2);
-        sqr_add_c2(a,2,0,c3,c1,c2);
-        r[2]=c3;
-        c3=0;
-        sqr_add_c2(a,3,0,c1,c2,c3);
-        sqr_add_c2(a,2,1,c1,c2,c3);
-        r[3]=c1;
-        c1=0;
-        sqr_add_c(a,2,c2,c3,c1);
-        sqr_add_c2(a,3,1,c2,c3,c1);
-        sqr_add_c2(a,4,0,c2,c3,c1);
-        r[4]=c2;
-        c2=0;
-        sqr_add_c2(a,5,0,c3,c1,c2);
-        sqr_add_c2(a,4,1,c3,c1,c2);
-        sqr_add_c2(a,3,2,c3,c1,c2);
-        r[5]=c3;
-        c3=0;
-        sqr_add_c(a,3,c1,c2,c3);
-        sqr_add_c2(a,4,2,c1,c2,c3);
-        sqr_add_c2(a,5,1,c1,c2,c3);
-        sqr_add_c2(a,6,0,c1,c2,c3);
-        r[6]=c1;
-        c1=0;
-        sqr_add_c2(a,7,0,c2,c3,c1);
-        sqr_add_c2(a,6,1,c2,c3,c1);
-        sqr_add_c2(a,5,2,c2,c3,c1);
-        sqr_add_c2(a,4,3,c2,c3,c1);
-        r[7]=c2;
-        c2=0;
-        sqr_add_c(a,4,c3,c1,c2);
-        sqr_add_c2(a,5,3,c3,c1,c2);
-        sqr_add_c2(a,6,2,c3,c1,c2);
-        sqr_add_c2(a,7,1,c3,c1,c2);
-        r[8]=c3;
-        c3=0;
-        sqr_add_c2(a,7,2,c1,c2,c3);
-        sqr_add_c2(a,6,3,c1,c2,c3);
-        sqr_add_c2(a,5,4,c1,c2,c3);
-        r[9]=c1;
-        c1=0;
-        sqr_add_c(a,5,c2,c3,c1);
-        sqr_add_c2(a,6,4,c2,c3,c1);
-        sqr_add_c2(a,7,3,c2,c3,c1);
-        r[10]=c2;
-        c2=0;
-        sqr_add_c2(a,7,4,c3,c1,c2);
-        sqr_add_c2(a,6,5,c3,c1,c2);
-        r[11]=c3;
-        c3=0;
-        sqr_add_c(a,6,c1,c2,c3);
-        sqr_add_c2(a,7,5,c1,c2,c3);
-        r[12]=c1;
-        c1=0;
-        sqr_add_c2(a,7,6,c2,c3,c1);
-        r[13]=c2;
-        c2=0;
-        sqr_add_c(a,7,c3,c1,c2);
-        r[14]=c3;
-        r[15]=c1;
-        }
-
-void bn_sqr_comba44(BN_ULONG *r, BN_ULONG *a)
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t,tt;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-        c1=0;
-        c2=0;
-        c3=0;
-        sqr_add_c(a,0,c1,c2,c3);
-        r[0]=c1;
-        c1=0;
-        sqr_add_c2(a,1,0,c2,c3,c1);
-        r[1]=c2;
-        c2=0;
-        sqr_add_c(a,1,c3,c1,c2);
-        sqr_add_c2(a,2,0,c3,c1,c2);
-        r[2]=c3;
-        c3=0;
-        sqr_add_c2(a,3,0,c1,c2,c3);
-        sqr_add_c2(a,2,1,c1,c2,c3);
-        r[3]=c1;
-        c1=0;
-        sqr_add_c(a,2,c2,c3,c1);
-        sqr_add_c2(a,3,1,c2,c3,c1);
-        r[4]=c2;
-        c2=0;
-        sqr_add_c2(a,3,2,c3,c1,c2);
-        r[5]=c3;
-        c3=0;
-        sqr_add_c(a,3,c1,c2,c3);
-        r[6]=c1;
-        r[7]=c2;
-        }
diff --git a/src/lib/libcrypto/bn/bn_ctx.c b/src/lib/libcrypto/bn/bn_ctx.c
new file mode 100644
index 0000000000..46132fd180
--- /dev/null
+++ b/src/lib/libcrypto/bn/bn_ctx.c
@@ -0,0 +1,144 @@
+/* crypto/bn/bn_ctx.c */
+/* Written by Ulf Moeller for the OpenSSL project. */
+/* ====================================================================
+ * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+#ifndef BN_CTX_DEBUG
+# undef NDEBUG /* avoid conflicting definitions */
+# define NDEBUG
+#endif
+
+#include <stdio.h>
+#include <assert.h>
+#include "cryptlib.h"
+#include <openssl/bn.h>
+
+
+BN_CTX *BN_CTX_new(void)
+        {
+        BN_CTX *ret;
+
+        ret=(BN_CTX *)Malloc(sizeof(BN_CTX));
+        if (ret == NULL)
+                {
+                BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);
+                return(NULL);
+                }
+
+        BN_CTX_init(ret);
+        ret->flags=BN_FLG_MALLOCED;
+        return(ret);
+        }
+
+void BN_CTX_init(BN_CTX *ctx)
+        {
+        int i;
+        ctx->tos = 0;
+        ctx->flags = 0;
+        ctx->depth = 0;
+        ctx->too_many = 0;
+        for (i = 0; i < BN_CTX_NUM; i++)
+                BN_init(&(ctx->bn[i]));
+        }
+
+void BN_CTX_free(BN_CTX *ctx)
+        {
+        int i;
+
+        if (ctx == NULL) return;
+        assert(ctx->depth == 0);
+
+        for (i=0; i < BN_CTX_NUM; i++)
+                BN_clear_free(&(ctx->bn[i]));
+        if (ctx->flags & BN_FLG_MALLOCED)
+                Free(ctx);
+        }
+
+void BN_CTX_start(BN_CTX *ctx)
+        {
+        if (ctx->depth < BN_CTX_NUM_POS)
+                ctx->pos[ctx->depth] = ctx->tos;
+        ctx->depth++;
+        }
+
+BIGNUM *BN_CTX_get(BN_CTX *ctx)
+        {
+        if (ctx->depth > BN_CTX_NUM_POS || ctx->tos >= BN_CTX_NUM)
+                {
+                if (!ctx->too_many)
+                        {
+                        BNerr(BN_F_BN_CTX_GET,BN_R_TOO_MANY_TEMPORARY_VARIABLES);
+                        /* disable error code until BN_CTX_end is called: */
+                        ctx->too_many = 1;
+                        }
+                return NULL;
+                }
+        return (&(ctx->bn[ctx->tos++]));
+        }
+
+void BN_CTX_end(BN_CTX *ctx)
+        {
+        if (ctx == NULL) return;
+        assert(ctx->depth > 0);
+        if (ctx->depth == 0)
+                /* should never happen, but we can tolerate it if not in
+                 * debug mode (could be a 'goto err' in the calling function
+                 * before BN_CTX_start was reached) */
+                BN_CTX_start(ctx);
+
+        ctx->too_many = 0;
+        ctx->depth--;
+        if (ctx->depth < BN_CTX_NUM_POS)
+                ctx->tos = ctx->pos[ctx->depth];
+        }
diff --git a/src/lib/libcrypto/bn/bn_div.c b/src/lib/libcrypto/bn/bn_div.c
index 150dd289a5..07af1d3b44 100644
--- a/src/lib/libcrypto/bn/bn_div.c
+++ b/src/lib/libcrypto/bn/bn_div.c
@@ -63,9 +63,11 @@
 
 /* The old slow way */
 #if 0
-int BN_div(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx)
+int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
+           BN_CTX *ctx)
         {
         int i,nm,nd;
+        int ret = 0;
         BIGNUM *D;
 
         bn_check_top(m);
@@ -84,14 +86,17 @@ int BN_div(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx)
                 return(1);
                 }
 
-        D= &(ctx->bn[ctx->tos]);
-        if (dv == NULL) dv= &(ctx->bn[ctx->tos+1]);
-        if (rem == NULL) rem= &(ctx->bn[ctx->tos+2]);
+        BN_CTX_start(ctx);
+        D = BN_CTX_get(ctx);
+        if (dv == NULL) dv = BN_CTX_get(ctx);
+        if (rem == NULL) rem = BN_CTX_get(ctx);
+        if (D == NULL || dv == NULL || rem == NULL)
+                goto end;
 
         nd=BN_num_bits(d);
         nm=BN_num_bits(m);
-        if (BN_copy(D,d) == NULL) return(0);
-        if (BN_copy(rem,m) == NULL) return(0);
+        if (BN_copy(D,d) == NULL) goto end;
+        if (BN_copy(rem,m) == NULL) goto end;
 
         /* The next 2 are needed so we can do a dv->d[0]|=1 later
          * since BN_lshift1 will only work once there is a value :-) */
@@ -99,25 +104,54 @@ int BN_div(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BIGNUM *d, BN_CTX *ctx)
         bn_wexpand(dv,1);
         dv->top=1;
 
-        if (!BN_lshift(D,D,nm-nd)) return(0);
+        if (!BN_lshift(D,D,nm-nd)) goto end;
         for (i=nm-nd; i>=0; i--)
                 {
-                if (!BN_lshift1(dv,dv)) return(0);
+                if (!BN_lshift1(dv,dv)) goto end;
                 if (BN_ucmp(rem,D) >= 0)
                         {
                         dv->d[0]|=1;
-                        if (!BN_usub(rem,rem,D)) return(0);
+                        if (!BN_usub(rem,rem,D)) goto end;
                         }
 /* CAN IMPROVE (and have now :=) */
-                if (!BN_rshift1(D,D)) return(0);
+                if (!BN_rshift1(D,D)) goto end;
                 }
         rem->neg=BN_is_zero(rem)?0:m->neg;
         dv->neg=m->neg^d->neg;
-        return(1);
+        ret = 1;
+ end:
+        BN_CTX_end(ctx);
+        return(ret);
         }
 
 #else
 
+#if !defined(NO_ASM) && !defined(NO_INLINE_ASM) && !defined(PEDANTIC) && !defined(BN_DIV3W)
+# if defined(__GNUC__) && __GNUC__>=2
+#  if defined(__i386)
+   /*
+    * There were two reasons for implementing this template:
+    * - GNU C generates a call to a function (__udivdi3 to be exact)
+    *   in reply to ((((BN_ULLONG)n0)<<BN_BITS2)|n1)/d0 (I fail to
+    *   understand why...);
+    * - divl doesn't only calculate quotient, but also leaves
+    *   remainder in %edx which we can definitely use here:-)
+    *
+    *                                   <appro@fy.chalmers.se>
+    */
+#  define bn_div_words(n0,n1,d0)                \
+        ({  asm volatile (                      \
+                "divl   %4"                     \
+                : "=a"(q), "=d"(rem)            \
+                : "a"(n1), "d"(n0), "g"(d0)     \
+                : "cc");                        \
+            q;                                  \
+        })
+#  define REMAINDER_IS_ALREADY_CALCULATED
+#  endif /* __<cpu> */
+# endif /* __GNUC__ */
+#endif /* NO_ASM */
+
 int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
            BN_CTX *ctx)
         {
@@ -144,13 +178,15 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
                 return(1);
                 }
 
-        tmp= &(ctx->bn[ctx->tos]);
+        BN_CTX_start(ctx);
+        tmp=BN_CTX_get(ctx);
         tmp->neg=0;
-        snum= &(ctx->bn[ctx->tos+1]);
-        sdiv= &(ctx->bn[ctx->tos+2]);
+        snum=BN_CTX_get(ctx);
+        sdiv=BN_CTX_get(ctx);
         if (dv == NULL)
-                res= &(ctx->bn[ctx->tos+3]);
+                res=BN_CTX_get(ctx);
         else    res=dv;
+        if (res == NULL) goto err;
 
         /* First we normalise the numbers */
         norm_shift=BN_BITS2-((BN_num_bits(divisor))%BN_BITS2);
@@ -202,97 +238,76 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
                 {
                 BN_ULONG q,l0;
 #ifdef BN_DIV3W
-                q=bn_div_3_words(wnump,d0,d1);
+                q=bn_div_3_words(wnump,d1,d0);
 #else
-
-#if !defined(NO_ASM) && !defined(PEDANTIC)
-# if defined(__GNUC__) && __GNUC__>=2
-#  if defined(__i386)
-   /*
-    * There were two reasons for implementing this template:
-    * - GNU C generates a call to a function (__udivdi3 to be exact)
-    *   in reply to ((((BN_ULLONG)n0)<<BN_BITS2)|n1)/d0 (I fail to
-    *   understand why...);
-    * - divl doesn't only calculate quotient, but also leaves
-    *   remainder in %edx which we can definitely use here:-)
-    *
-    *                                   <appro@fy.chalmers.se>
-    */
-#  define bn_div_words(n0,n1,d0)                \
-        ({  asm volatile (                      \
-                "divl   %4"                     \
-                : "=a"(q), "=d"(rem)            \
-                : "a"(n1), "d"(n0), "g"(d0)     \
-                : "cc");                        \
-            q;                                  \
-        })
-#  define REMINDER_IS_ALREADY_CALCULATED
-#  endif /* __<cpu> */
-# endif /* __GNUC__ */
-#endif /* NO_ASM */
                 BN_ULONG n0,n1,rem=0;
 
                 n0=wnump[0];
                 n1=wnump[-1];
                 if (n0 == d0)
                         q=BN_MASK2;
-                else
+                else                    /* n0 < d0 */
+                        {
+#ifdef BN_LLONG
+                        BN_ULLONG t2;
+
 #if defined(BN_LLONG) && defined(BN_DIV2W) && !defined(bn_div_words)
-                        q=((((BN_ULLONG)n0)<<BN_BITS2)|n1)/d0;
+                        q=(BN_ULONG)(((((BN_ULLONG)n0)<<BN_BITS2)|n1)/d0);
 #else
                         q=bn_div_words(n0,n1,d0);
 #endif
-                {
-#ifdef BN_LLONG
-                BN_ULLONG t2;
-
-#ifndef REMINDER_IS_ALREADY_CALCULATED
-                /*
-                 * rem doesn't have to be BN_ULLONG. The least we
-                 * know it's less that d0, isn't it?
-                 */
-                rem=(n1-q*d0)&BN_MASK2;
+
+#ifndef REMAINDER_IS_ALREADY_CALCULATED
+                        /*
+                         * rem doesn't have to be BN_ULLONG. The least we
+                         * know it's less that d0, isn't it?
+                         */
+                        rem=(n1-q*d0)&BN_MASK2;
 #endif
-                t2=(BN_ULLONG)d1*q;
+                        t2=(BN_ULLONG)d1*q;
+
+                        for (;;)
+                                {
+                                if (t2 <= ((((BN_ULLONG)rem)<<BN_BITS2)|wnump[-2]))
+                                        break;
+                                q--;
+                                rem += d0;
+                                if (rem < d0) break; /* don't let rem overflow */
+                                t2 -= d1;
+                                }
+#else /* !BN_LLONG */
+                        BN_ULONG t2l,t2h,ql,qh;
 
-                for (;;)
-                        {
-                        if (t2 <= ((((BN_ULLONG)rem)<<BN_BITS2)|wnump[-2]))
-                                break;
-                        q--;
-                        rem += d0;
-                        if (rem < d0) break; /* don't let rem overflow */
-                        t2 -= d1;
-                        }
+                        q=bn_div_words(n0,n1,d0);
+#ifndef REMAINDER_IS_ALREADY_CALCULATED
+                        rem=(n1-q*d0)&BN_MASK2;
+#endif
+
+#ifdef BN_UMULT_HIGH
+                        t2l = d1 * q;
+                        t2h = BN_UMULT_HIGH(d1,q);
 #else
-                BN_ULONG t2l,t2h,ql,qh;
-
-#ifndef REMINDER_IS_ALREADY_CALCULATED
-                /*
-                 * It's more than enough with the only multiplication.
-                 * See the comment above in BN_LLONG section...
-                 */
-                rem=(n1-q*d0)&BN_MASK2;
+                        t2l=LBITS(d1); t2h=HBITS(d1);
+                        ql =LBITS(q);  qh =HBITS(q);
+                        mul64(t2l,t2h,ql,qh); /* t2=(BN_ULLONG)d1*q; */
 #endif
-                t2l=LBITS(d1); t2h=HBITS(d1);
-                ql =LBITS(q);  qh =HBITS(q);
-                mul64(t2l,t2h,ql,qh); /* t2=(BN_ULLONG)d1*q; */
 
-                for (;;)
-                        {
-                        if ((t2h < rem) ||
-                                ((t2h == rem) && (t2l <= wnump[-2])))
-                                break;
-                        q--;
-                        rem += d0;
-                        if (rem < d0) break; /* don't let rem overflow */
-                        if (t2l < d1) t2h--; t2l -= d1;
+                        for (;;)
+                                {
+                                if ((t2h < rem) ||
+                                        ((t2h == rem) && (t2l <= wnump[-2])))
+                                        break;
+                                q--;
+                                rem += d0;
+                                if (rem < d0) break; /* don't let rem overflow */
+                                if (t2l < d1) t2h--; t2l -= d1;
+                                }
+#endif /* !BN_LLONG */
                         }
-#endif
-                }
 #endif /* !BN_DIV3W */
-                wnum.d--; wnum.top++;
+
                 l0=bn_mul_words(tmp->d,sdiv->d,div_n,q);
+                wnum.d--; wnum.top++;
                 tmp->d[div_n]=l0;
                 for (j=div_n+1; j>0; j--)
                         if (tmp->d[j-1]) break;
@@ -318,8 +333,10 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
                 BN_rshift(rm,snum,norm_shift);
                 rm->neg=num->neg;
                 }
+        BN_CTX_end(ctx);
         return(1);
 err:
+        BN_CTX_end(ctx);
         return(0);
         }
 
@@ -335,22 +352,27 @@ int BN_mod(BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx)
         if (BN_ucmp(m,d) < 0)
                 return((BN_copy(rem,m) == NULL)?0:1);
 
-        dv= &(ctx->bn[ctx->tos]);
+        BN_CTX_start(ctx);
+        dv=BN_CTX_get(ctx);
 
-        if (!BN_copy(rem,m)) return(0);
+        if (!BN_copy(rem,m)) goto err;
 
         nm=BN_num_bits(rem);
         nd=BN_num_bits(d);
-        if (!BN_lshift(dv,d,nm-nd)) return(0);
+        if (!BN_lshift(dv,d,nm-nd)) goto err;
         for (i=nm-nd; i>=0; i--)
                 {
                 if (BN_cmp(rem,dv) >= 0)
                         {
-                        if (!BN_sub(rem,rem,dv)) return(0);
+                        if (!BN_sub(rem,rem,dv)) goto err;
                         }
-                if (!BN_rshift1(dv,dv)) return(0);
+                if (!BN_rshift1(dv,dv)) goto err;
                 }
+        BN_CTX_end(ctx);
         return(1);
+ err:
+        BN_CTX_end(ctx);
+        return(0);
 #else
         return(BN_div(NULL,rem,m,d,ctx));
 #endif
diff --git a/src/lib/libcrypto/bn/bn_err.c b/src/lib/libcrypto/bn/bn_err.c
index 73e80774e5..f3b9497dca 100644
--- a/src/lib/libcrypto/bn/bn_err.c
+++ b/src/lib/libcrypto/bn/bn_err.c
@@ -71,6 +71,7 @@ static ERR_STRING_DATA BN_str_functs[]=
 {ERR_PACK(0,BN_F_BN_BLINDING_UPDATE,0), "BN_BLINDING_update"},
 {ERR_PACK(0,BN_F_BN_BN2DEC,0),  "BN_bn2dec"},
 {ERR_PACK(0,BN_F_BN_BN2HEX,0),  "BN_bn2hex"},
+{ERR_PACK(0,BN_F_BN_CTX_GET,0), "BN_CTX_get"},
 {ERR_PACK(0,BN_F_BN_CTX_NEW,0), "BN_CTX_new"},
 {ERR_PACK(0,BN_F_BN_DIV,0),     "BN_div"},
 {ERR_PACK(0,BN_F_BN_EXPAND2,0), "bn_expand2"},
@@ -95,6 +96,7 @@ static ERR_STRING_DATA BN_str_reasons[]=
 {BN_R_INVALID_LENGTH                     ,"invalid length"},
 {BN_R_NOT_INITIALIZED                    ,"not initialized"},
 {BN_R_NO_INVERSE                         ,"no inverse"},
+{BN_R_TOO_MANY_TEMPORARY_VARIABLES       ,"too many temporary variables"},
 {0,NULL}
         };
 
diff --git a/src/lib/libcrypto/bn/bn_exp.c b/src/lib/libcrypto/bn/bn_exp.c
index 2df1614ada..0c11601675 100644
--- a/src/lib/libcrypto/bn/bn_exp.c
+++ b/src/lib/libcrypto/bn/bn_exp.c
@@ -59,6 +59,12 @@
 #include <stdio.h>
 #include "cryptlib.h"
 #include "bn_lcl.h"
+#ifdef ATALLA
+# include <alloca.h>
+# include <atasi.h>
+# include <assert.h>
+# include <dlfcn.h>
+#endif
 
 #define TABLE_SIZE      16
 
@@ -72,7 +78,8 @@ int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
         bn_check_top(b);
         bn_check_top(m);
 
-        t= &(ctx->bn[ctx->tos++]);
+        BN_CTX_start(ctx);
+        if ((t = BN_CTX_get(ctx)) == NULL) goto err;
         if (a == b)
                 { if (!BN_sqr(t,a,ctx)) goto err; }
         else
@@ -80,7 +87,7 @@ int BN_mod_mul(BIGNUM *ret, BIGNUM *a, BIGNUM *b, const BIGNUM *m, BN_CTX *ctx)
         if (!BN_mod(ret,t,m,ctx)) goto err;
         r=1;
 err:
-        ctx->tos--;
+        BN_CTX_end(ctx);
         return(r);
         }
 
@@ -91,8 +98,10 @@ int BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx)
         int i,bits,ret=0;
         BIGNUM *v,*tmp;
 
-        v= &(ctx->bn[ctx->tos++]);
-        tmp= &(ctx->bn[ctx->tos++]);
+        BN_CTX_start(ctx);
+        v = BN_CTX_get(ctx);
+        tmp = BN_CTX_get(ctx);
+        if (v == NULL || tmp == NULL) goto err;
 
         if (BN_copy(v,a) == NULL) goto err;
         bits=BN_num_bits(p);
@@ -113,7 +122,7 @@ int BN_mod_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m, BN_CTX *ctx)
                 }
         ret=1;
 err:
-        ctx->tos-=2;
+        BN_CTX_end(ctx);
         return(ret);
         }
 
@@ -122,15 +131,15 @@ err:
 /* this one works - simple but works */
 int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx)
         {
-        int i,bits,ret=0,tos;
+        int i,bits,ret=0;
         BIGNUM *v,*rr;
 
-        tos=ctx->tos;
-        v= &(ctx->bn[ctx->tos++]);
+        BN_CTX_start(ctx);
         if ((r == a) || (r == p))
-                rr= &(ctx->bn[ctx->tos++]);
+                rr = BN_CTX_get(ctx);
         else
-                rr=r;
+                rr = r;
+        if ((v = BN_CTX_get(ctx)) == NULL) goto err;
 
         if (BN_copy(v,a) == NULL) goto err;
         bits=BN_num_bits(p);
@@ -149,11 +158,178 @@ int BN_exp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BN_CTX *ctx)
                 }
         ret=1;
 err:
-        ctx->tos=tos;
         if (r != rr) BN_copy(r,rr);
+        BN_CTX_end(ctx);
         return(ret);
         }
 
+#ifdef ATALLA
+
+/*
+ * This routine will dynamically check for the existance of an Atalla AXL-200
+ * SSL accelerator module.  If one is found, the variable
+ * asi_accelerator_present is set to 1 and the function pointers
+ * ptr_ASI_xxxxxx above will be initialized to corresponding ASI API calls.
+ */
+typedef int tfnASI_GetPerformanceStatistics(int reset_flag,
+                                            unsigned int *ret_buf);
+typedef int tfnASI_GetHardwareConfig(long card_num, unsigned int *ret_buf);
+typedef int tfnASI_RSAPrivateKeyOpFn(RSAPrivateKey * rsaKey,
+                                     unsigned char *output,
+                                     unsigned char *input,
+                                     unsigned int modulus_len);
+
+static tfnASI_GetHardwareConfig *ptr_ASI_GetHardwareConfig;
+static tfnASI_RSAPrivateKeyOpFn *ptr_ASI_RSAPrivateKeyOpFn;
+static tfnASI_GetPerformanceStatistics *ptr_ASI_GetPerformanceStatistics;
+static int asi_accelerator_present;
+static int tried_atalla;
+
+void atalla_initialize_accelerator_handle(void)
+        {
+        void *dl_handle;
+        int status;
+        unsigned int config_buf[1024]; 
+        static int tested;
+
+        if(tested)
+                return;
+
+        tested=1;
+
+        bzero((void *)config_buf, 1024);
+
+        /*
+         * Check to see if the library is present on the system
+         */
+        dl_handle = dlopen("atasi.so", RTLD_NOW);
+        if (dl_handle == (void *) NULL)
+                {
+/*              printf("atasi.so library is not present on the system\n");
+                printf("No HW acceleration available\n");*/
+                return;
+                }
+
+        /*
+         * The library is present.  Now we'll check to insure that the
+         * LDM is up and running. First we'll get the address of the
+         * function in the atasi library that we need to see if the
+         * LDM is operating.
+         */
+
+        ptr_ASI_GetHardwareConfig =
+          (tfnASI_GetHardwareConfig *)dlsym(dl_handle,"ASI_GetHardwareConfig");
+
+        if (ptr_ASI_GetHardwareConfig)
+                {
+                /*
+                 * We found the call, now we'll get our config
+                 * status.  If we get a non 0 result, the LDM is not
+                 * running and we cannot use the Atalla ASI *
+                 * library.
+                 */
+                status = (*ptr_ASI_GetHardwareConfig)(0L, config_buf);
+                if (status != 0)
+                        {
+                        printf("atasi.so library is present but not initialized\n");
+                        printf("No HW acceleration available\n");
+                        return;
+                        }    
+                }
+        else
+                {
+/*              printf("We found the library, but not the function. Very Strange!\n");*/
+                return ;
+                }
+
+        /* 
+         * It looks like we have acceleration capabilities.  Load up the
+         * pointers to our ASI API calls.
+         */
+        ptr_ASI_RSAPrivateKeyOpFn=
+          (tfnASI_RSAPrivateKeyOpFn *)dlsym(dl_handle, "ASI_RSAPrivateKeyOpFn");
+        if (ptr_ASI_RSAPrivateKeyOpFn == NULL)
+                {
+/*              printf("We found the library, but no RSA function. Very Strange!\n");*/
+                return;
+                }
+
+        ptr_ASI_GetPerformanceStatistics =
+          (tfnASI_GetPerformanceStatistics *)dlsym(dl_handle, "ASI_GetPerformanceStatistics");
+        if (ptr_ASI_GetPerformanceStatistics == NULL)
+                {
+/*              printf("We found the library, but no stat function. Very Strange!\n");*/
+                return;
+              }
+
+        /*
+         * Indicate that acceleration is available
+         */
+        asi_accelerator_present = 1;
+
+/*      printf("This system has acceleration!\n");*/
+
+        return;
+        }
+
+/* make sure this only gets called once when bn_mod_exp calls bn_mod_exp_mont */
+int BN_mod_exp_atalla(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m)
+        {
+        unsigned char *abin;
+        unsigned char *pbin;
+        unsigned char *mbin;
+        unsigned char *rbin;
+        int an,pn,mn,ret;
+        RSAPrivateKey keydata;
+
+        atalla_initialize_accelerator_handle();
+        if(!asi_accelerator_present)
+                return 0;
+
+
+/* We should be able to run without size testing */
+# define ASIZE  128
+        an=BN_num_bytes(a);
+        pn=BN_num_bytes(p);
+        mn=BN_num_bytes(m);
+
+        if(an <= ASIZE && pn <= ASIZE && mn <= ASIZE)
+            {
+            int size=mn;
+
+            assert(an <= mn);
+            abin=alloca(size);
+            memset(abin,'\0',mn);
+            BN_bn2bin(a,abin+size-an);
+
+            pbin=alloca(pn);
+            BN_bn2bin(p,pbin);
+
+            mbin=alloca(size);
+            memset(mbin,'\0',mn);
+            BN_bn2bin(m,mbin+size-mn);
+
+            rbin=alloca(size);
+
+            memset(&keydata,'\0',sizeof keydata);
+            keydata.privateExponent.data=pbin;
+            keydata.privateExponent.len=pn;
+            keydata.modulus.data=mbin;
+            keydata.modulus.len=size;
+
+            ret=(*ptr_ASI_RSAPrivateKeyOpFn)(&keydata,rbin,abin,keydata.modulus.len);
+/*fprintf(stderr,"!%s\n",BN_bn2hex(a));*/
+            if(!ret)
+                {
+                BN_bin2bn(rbin,keydata.modulus.len,r);
+/*fprintf(stderr,"?%s\n",BN_bn2hex(r));*/
+                return 1;
+                }
+            }
+        return 0;
+        }
+#endif /* def ATALLA */
+
 int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
                BN_CTX *ctx)
         {
@@ -163,6 +339,13 @@ int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
         bn_check_top(p);
         bn_check_top(m);
 
+#ifdef ATALLA
+        if(BN_mod_exp_atalla(r,a,p,m))
+            return 1;
+/* If it fails, try the other methods (but don't try atalla again) */
+        tried_atalla=1;
+#endif
+
 #ifdef MONT_MUL_MOD
         /* I have finally been able to take out this pre-condition of
          * the top bit being set.  It was caused by an error in BN_div
@@ -180,6 +363,10 @@ int BN_mod_exp(BIGNUM *r, BIGNUM *a, const BIGNUM *p, const BIGNUM *m,
                 { ret=BN_mod_exp_simple(r,a,p,m,ctx); }
 #endif
 
+#ifdef ATALLA
+        tried_atalla=0;
+#endif
+
         return(ret);
         }
 
@@ -193,7 +380,6 @@ int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
         BIGNUM val[TABLE_SIZE];
         BN_RECP_CTX recp;
 
-        aa= &(ctx->bn[ctx->tos++]);
         bits=BN_num_bits(p);
 
         if (bits == 0)
@@ -201,6 +387,10 @@ int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                 BN_one(r);
                 return(1);
                 }
+
+        BN_CTX_start(ctx);
+        if ((aa = BN_CTX_get(ctx)) == NULL) goto err;
+
         BN_RECP_CTX_init(&recp);
         if (BN_RECP_CTX_set(&recp,m,ctx) <= 0) goto err;
 
@@ -289,7 +479,7 @@ int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                 }
         ret=1;
 err:
-        ctx->tos--;
+        BN_CTX_end(ctx);
         for (i=0; i<ts; i++)
                 BN_clear_free(&(val[i]));
         BN_RECP_CTX_free(&recp);
@@ -312,19 +502,27 @@ int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
         bn_check_top(p);
         bn_check_top(m);
 
+#ifdef ATALLA
+        if(!tried_atalla && BN_mod_exp_atalla(rr,a,p,m))
+            return 1;
+/* If it fails, try the other methods */
+#endif
+
         if (!(m->d[0] & 1))
                 {
                 BNerr(BN_F_BN_MOD_EXP_MONT,BN_R_CALLED_WITH_EVEN_MODULUS);
                 return(0);
                 }
-        d= &(ctx->bn[ctx->tos++]);
-        r= &(ctx->bn[ctx->tos++]);
         bits=BN_num_bits(p);
         if (bits == 0)
                 {
-                BN_one(r);
+                BN_one(rr);
                 return(1);
                 }
+        BN_CTX_start(ctx);
+        d = BN_CTX_get(ctx);
+        r = BN_CTX_get(ctx);
+        if (d == NULL || r == NULL) goto err;
 
         /* If this is not done, things will break in the montgomery
          * part */
@@ -432,7 +630,7 @@ int BN_mod_exp_mont(BIGNUM *rr, BIGNUM *a, const BIGNUM *p,
         ret=1;
 err:
         if ((in_mont == NULL) && (mont != NULL)) BN_MONT_CTX_free(mont);
-        ctx->tos-=2;
+        BN_CTX_end(ctx);
         for (i=0; i<ts; i++)
                 BN_clear_free(&(val[i]));
         return(ret);
@@ -448,7 +646,6 @@ int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
         BIGNUM *d;
         BIGNUM val[TABLE_SIZE];
 
-        d= &(ctx->bn[ctx->tos++]);
         bits=BN_num_bits(p);
 
         if (bits == 0)
@@ -457,6 +654,9 @@ int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
                 return(1);
                 }
 
+        BN_CTX_start(ctx);
+        if ((d = BN_CTX_get(ctx)) == NULL) goto err;
+
         BN_init(&(val[0]));
         ts=1;
         if (!BN_mod(&(val[0]),a,m,ctx)) goto err;               /* 1 */
@@ -541,7 +741,7 @@ int BN_mod_exp_simple(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
                 }
         ret=1;
 err:
-        ctx->tos--;
+        BN_CTX_end(ctx);
         for (i=0; i<ts; i++)
                 BN_clear_free(&(val[i]));
         return(ret);
diff --git a/src/lib/libcrypto/bn/bn_exp2.c b/src/lib/libcrypto/bn/bn_exp2.c
index 1132d53365..4f4e9e3299 100644
--- a/src/lib/libcrypto/bn/bn_exp2.c
+++ b/src/lib/libcrypto/bn/bn_exp2.c
@@ -9,7 +9,7 @@
  * bits=1  75.4%  79.4%
  * bits=2  61.2%  62.4%
  * bits=3  61.3%  59.3%
- * The lack of speed improvment is also a function of the pre-calculation
+ * The lack of speed improvement is also a function of the pre-calculation
  * which could be removed.
  */
 #define EXP2_TABLE_BITS 2 /* 1  2  3  4  5  */
@@ -35,15 +35,19 @@ int BN_mod_exp2_mont(BIGNUM *rr, BIGNUM *a1, BIGNUM *p1, BIGNUM *a2,
                 BNerr(BN_F_BN_MOD_EXP_MONT,BN_R_CALLED_WITH_EVEN_MODULUS);
                 return(0);
                 }
-        d= &(ctx->bn[ctx->tos++]);
-        r= &(ctx->bn[ctx->tos++]);
         bits1=BN_num_bits(p1);
         bits2=BN_num_bits(p2);
         if ((bits1 == 0) && (bits2 == 0))
                 {
-                BN_one(r);
+                BN_one(rr);
                 return(1);
                 }
+
+        BN_CTX_start(ctx);
+        d = BN_CTX_get(ctx);
+        r = BN_CTX_get(ctx);
+        if (d == NULL || r == NULL) goto err;
+
         bits=(bits1 > bits2)?bits1:bits2;
 
         /* If this is not done, things will break in the montgomery
@@ -183,7 +187,7 @@ int BN_mod_exp2_mont(BIGNUM *rr, BIGNUM *a1, BIGNUM *p1, BIGNUM *a2,
         ret=1;
 err:
         if ((in_mont == NULL) && (mont != NULL)) BN_MONT_CTX_free(mont);
-        ctx->tos-=2;
+        BN_CTX_end(ctx);
         for (i=0; i<ts; i++)
                 {
                 for (j=0; j<ts; j++)
diff --git a/src/lib/libcrypto/bn/bn_gcd.c b/src/lib/libcrypto/bn/bn_gcd.c
index 64a76f4498..398207196b 100644
--- a/src/lib/libcrypto/bn/bn_gcd.c
+++ b/src/lib/libcrypto/bn/bn_gcd.c
@@ -61,6 +61,7 @@
 #include "bn_lcl.h"
 
 static BIGNUM *euclid(BIGNUM *a, BIGNUM *b);
+
 int BN_gcd(BIGNUM *r, BIGNUM *in_a, BIGNUM *in_b, BN_CTX *ctx)
         {
         BIGNUM *a,*b,*t;
@@ -69,8 +70,10 @@ int BN_gcd(BIGNUM *r, BIGNUM *in_a, BIGNUM *in_b, BN_CTX *ctx)
         bn_check_top(in_a);
         bn_check_top(in_b);
 
-        a= &(ctx->bn[ctx->tos]);
-        b= &(ctx->bn[ctx->tos+1]);
+        BN_CTX_start(ctx);
+        a = BN_CTX_get(ctx);
+        b = BN_CTX_get(ctx);
+        if (a == NULL || b == NULL) goto err;
 
         if (BN_copy(a,in_a) == NULL) goto err;
         if (BN_copy(b,in_b) == NULL) goto err;
@@ -82,6 +85,7 @@ int BN_gcd(BIGNUM *r, BIGNUM *in_a, BIGNUM *in_b, BN_CTX *ctx)
         if (BN_copy(r,t) == NULL) goto err;
         ret=1;
 err:
+        BN_CTX_end(ctx);
         return(ret);
         }
 
@@ -142,20 +146,22 @@ err:
 /* solves ax == 1 (mod n) */
 BIGNUM *BN_mod_inverse(BIGNUM *in, BIGNUM *a, const BIGNUM *n, BN_CTX *ctx)
         {
-        BIGNUM *A,*B,*X,*Y,*M,*D,*R;
+        BIGNUM *A,*B,*X,*Y,*M,*D,*R=NULL;
         BIGNUM *T,*ret=NULL;
         int sign;
 
         bn_check_top(a);
         bn_check_top(n);
 
-        A= &(ctx->bn[ctx->tos]);
-        B= &(ctx->bn[ctx->tos+1]);
-        X= &(ctx->bn[ctx->tos+2]);
-        D= &(ctx->bn[ctx->tos+3]);
-        M= &(ctx->bn[ctx->tos+4]);
-        Y= &(ctx->bn[ctx->tos+5]);
-        ctx->tos+=6;
+        BN_CTX_start(ctx);
+        A = BN_CTX_get(ctx);
+        B = BN_CTX_get(ctx);
+        X = BN_CTX_get(ctx);
+        D = BN_CTX_get(ctx);
+        M = BN_CTX_get(ctx);
+        Y = BN_CTX_get(ctx);
+        if (Y == NULL) goto err;
+
         if (in == NULL)
                 R=BN_new();
         else
@@ -198,7 +204,7 @@ BIGNUM *BN_mod_inverse(BIGNUM *in, BIGNUM *a, const BIGNUM *n, BN_CTX *ctx)
         ret=R;
 err:
         if ((ret == NULL) && (in == NULL)) BN_free(R);
-        ctx->tos-=6;
+        BN_CTX_end(ctx);
         return(ret);
         }
 
diff --git a/src/lib/libcrypto/bn/bn_lcl.h b/src/lib/libcrypto/bn/bn_lcl.h
index 85a372695b..e36ccbc4c2 100644
--- a/src/lib/libcrypto/bn/bn_lcl.h
+++ b/src/lib/libcrypto/bn/bn_lcl.h
@@ -73,18 +73,53 @@ extern "C" {
 #define BN_MUL_LOW_RECURSIVE_SIZE_NORMAL        (32) /* 32 */
 #define BN_MONT_CTX_SET_SIZE_WORD               (64) /* 32 */
 
-#if 0
-#ifndef BN_MUL_COMBA
-/* #define bn_mul_comba8(r,a,b) bn_mul_normal(r,a,8,b,8) */
-/* #define bn_mul_comba4(r,a,b) bn_mul_normal(r,a,4,b,4) */
-#endif
-
-#ifndef BN_SQR_COMBA
-/* This is probably faster than using the C code - I need to check */
-#define bn_sqr_comba8(r,a)      bn_mul_normal(r,a,8,a,8)
-#define bn_sqr_comba4(r,a)      bn_mul_normal(r,a,4,a,4)
-#endif
-#endif
+#if !defined(NO_ASM) && !defined(NO_INLINE_ASM) && !defined(PEDANTIC)
+/*
+ * BN_UMULT_HIGH section.
+ *
+ * No, I'm not trying to overwhelm you when stating that the
+ * product of N-bit numbers is 2*N bits wide:-) No, I don't expect
+ * you to be impressed when I say that if the compiler doesn't
+ * support 2*N integer type, then you have to replace every N*N
+ * multiplication with 4 (N/2)*(N/2) accompanied by some shifts
+ * and additions which unavoidably results in severe performance
+ * penalties. Of course provided that the hardware is capable of
+ * producing 2*N result... That's when you normally start
+ * considering assembler implementation. However! It should be
+ * pointed out that some CPUs (most notably Alpha, PowerPC and
+ * upcoming IA-64 family:-) provide *separate* instruction
+ * calculating the upper half of the product placing the result
+ * into a general purpose register. Now *if* the compiler supports
+ * inline assembler, then it's not impossible to implement the
+ * "bignum" routines (and have the compiler optimize 'em)
+ * exhibiting "native" performance in C. That's what BN_UMULT_HIGH
+ * macro is about:-)
+ *
+ *                                      <appro@fy.chalmers.se>
+ */
+# if defined(__alpha) && (defined(SIXTY_FOUR_BIT_LONG) || defined(SIXTY_FOUR_BIT))
+#  if defined(__DECC)
+#   include <c_asm.h>
+#   define BN_UMULT_HIGH(a,b)   (BN_ULONG)asm("umulh %a0,%a1,%v0",(a),(b))
+#  elif defined(__GNUC__)
+#   define BN_UMULT_HIGH(a,b)   ({      \
+        register BN_ULONG ret;          \
+        asm ("umulh     %1,%2,%0"       \
+             : "=r"(ret)                \
+             : "r"(a), "r"(b));         \
+        ret;                    })
+#  endif        /* compiler */
+# elif defined(_ARCH_PPC) && defined(__64BIT__) && defined(SIXTY_FOUR_BIT_LONG)
+#  if defined(__GNUC__)
+#   define BN_UMULT_HIGH(a,b)   ({      \
+        register BN_ULONG ret;          \
+        asm ("mulhdu    %0,%1,%2"       \
+             : "=r"(ret)                \
+             : "r"(a), "r"(b));         \
+        ret;                    })
+#  endif        /* compiler */
+# endif         /* cpu */
+#endif          /* NO_ASM */
 
 /*************************************************************
  * Using the long long type
@@ -92,15 +127,12 @@ extern "C" {
 #define Lw(t)    (((BN_ULONG)(t))&BN_MASK2)
 #define Hw(t)    (((BN_ULONG)((t)>>BN_BITS2))&BN_MASK2)
 
-/* These are used for internal error checking and are not normally used */
+/* This is used for internal error checking and is not normally used */
 #ifdef BN_DEBUG
-#define bn_check_top(a) \
-        { if (((a)->top < 0) || ((a)->top > (a)->max)) \
-                { char *nullp=NULL; *nullp='z'; } }
-#define bn_check_num(a) if ((a) < 0) { char *nullp=NULL; *nullp='z'; }
+# include <assert.h>
+# define bn_check_top(a) assert ((a)->top >= 0 && (a)->top <= (a)->max);
 #else
-#define bn_check_top(a)
-#define bn_check_num(a)
+# define bn_check_top(a)
 #endif
 
 /* This macro is to add extra stuff for development checking */
@@ -134,8 +166,6 @@ extern "C" {
         bn_set_max(r); \
         }
 
-/* #define bn_expand(n,b) ((((b)/BN_BITS2) <= (n)->max)?(n):bn_expand2((n),(b))) */
-
 #ifdef BN_LLONG
 #define mul_add(r,a,w,c) { \
         BN_ULLONG t; \
@@ -151,6 +181,43 @@ extern "C" {
         (c)= Hw(t); \
         }
 
+#define sqr(r0,r1,a) { \
+        BN_ULLONG t; \
+        t=(BN_ULLONG)(a)*(a); \
+        (r0)=Lw(t); \
+        (r1)=Hw(t); \
+        }
+
+#elif defined(BN_UMULT_HIGH)
+#define mul_add(r,a,w,c) {              \
+        BN_ULONG high,low,ret,tmp=(a);  \
+        ret =  (r);                     \
+        high=  BN_UMULT_HIGH(w,tmp);    \
+        ret += (c);                     \
+        low =  (w) * tmp;               \
+        (c) =  (ret<(c))?1:0;           \
+        (c) += high;                    \
+        ret += low;                     \
+        (c) += (ret<low)?1:0;           \
+        (r) =  ret;                     \
+        }
+
+#define mul(r,a,w,c)    {               \
+        BN_ULONG high,low,ret,ta=(a);   \
+        low =  (w) * ta;                \
+        high=  BN_UMULT_HIGH(w,ta);     \
+        ret =  low + (c);               \
+        (c) =  high;                    \
+        (c) += (ret<low)?1:0;           \
+        (r) =  ret;                     \
+        }
+
+#define sqr(r0,r1,a)    {               \
+        BN_ULONG tmp=(a);               \
+        (r0) = tmp * tmp;               \
+        (r1) = BN_UMULT_HIGH(tmp,tmp);  \
+        }
+
 #else
 /*************************************************************
  * No long long type
@@ -228,21 +295,7 @@ extern "C" {
         (c)=h&BN_MASK2; \
         (r)=l&BN_MASK2; \
         }
-
-#endif
-
-OPENSSL_EXTERN int bn_limit_bits;
-OPENSSL_EXTERN int bn_limit_num;        /* (1<<bn_limit_bits) */
-/* Recursive 'low' limit */
-OPENSSL_EXTERN int bn_limit_bits_low;
-OPENSSL_EXTERN int bn_limit_num_low;    /* (1<<bn_limit_bits_low) */
-/* Do modified 'high' part calculation' */
-OPENSSL_EXTERN int bn_limit_bits_high;
-OPENSSL_EXTERN int bn_limit_num_high;   /* (1<<bn_limit_bits_high) */
-OPENSSL_EXTERN int bn_limit_bits_mont;
-OPENSSL_EXTERN int bn_limit_num_mont;   /* (1<<bn_limit_bits_mont) */
-
-BIGNUM *bn_expand2(BIGNUM *b, int bits);
+#endif /* !BN_LLONG */
 
 void bn_mul_normal(BN_ULONG *r,BN_ULONG *a,int na,BN_ULONG *b,int nb);
 void bn_mul_comba8(BN_ULONG *r,BN_ULONG *a,BN_ULONG *b);
diff --git a/src/lib/libcrypto/bn/bn_lib.c b/src/lib/libcrypto/bn/bn_lib.c
index 5d62d88e8b..0e6b12d9c3 100644
--- a/src/lib/libcrypto/bn/bn_lib.c
+++ b/src/lib/libcrypto/bn/bn_lib.c
@@ -71,14 +71,14 @@ const char *BN_version="Big Number" OPENSSL_VERSION_PTEXT;
  * 7 - 128 == 4096
  * 8 - 256 == 8192
  */
-OPENSSL_GLOBAL int bn_limit_bits=0;
-OPENSSL_GLOBAL int bn_limit_num=8;        /* (1<<bn_limit_bits) */
-OPENSSL_GLOBAL int bn_limit_bits_low=0;
-OPENSSL_GLOBAL int bn_limit_num_low=8;    /* (1<<bn_limit_bits_low) */
-OPENSSL_GLOBAL int bn_limit_bits_high=0;
-OPENSSL_GLOBAL int bn_limit_num_high=8;   /* (1<<bn_limit_bits_high) */
-OPENSSL_GLOBAL int bn_limit_bits_mont=0;
-OPENSSL_GLOBAL int bn_limit_num_mont=8;   /* (1<<bn_limit_bits_mont) */
+static int bn_limit_bits=0;
+static int bn_limit_num=8;        /* (1<<bn_limit_bits) */
+static int bn_limit_bits_low=0;
+static int bn_limit_num_low=8;    /* (1<<bn_limit_bits_low) */
+static int bn_limit_bits_high=0;
+static int bn_limit_num_high=8;   /* (1<<bn_limit_bits_high) */
+static int bn_limit_bits_mont=0;
+static int bn_limit_num_mont=8;   /* (1<<bn_limit_bits_mont) */
 
 void BN_set_params(int mult, int high, int low, int mont)
         {
@@ -304,42 +304,10 @@ BIGNUM *BN_new(void)
         return(ret);
         }
 
-
-BN_CTX *BN_CTX_new(void)
-        {
-        BN_CTX *ret;
-
-        ret=(BN_CTX *)Malloc(sizeof(BN_CTX));
-        if (ret == NULL)
-                {
-                BNerr(BN_F_BN_CTX_NEW,ERR_R_MALLOC_FAILURE);
-                return(NULL);
-                }
-
-        BN_CTX_init(ret);
-        ret->flags=BN_FLG_MALLOCED;
-        return(ret);
-        }
-
-void BN_CTX_init(BN_CTX *ctx)
-        {
-        memset(ctx,0,sizeof(BN_CTX));
-        ctx->tos=0;
-        ctx->flags=0;
-        }
-
-void BN_CTX_free(BN_CTX *c)
-        {
-        int i;
-
-        if(c == NULL)
-            return;
-
-        for (i=0; i<BN_CTX_NUM; i++)
-                BN_clear_free(&(c->bn[i]));
-        if (c->flags & BN_FLG_MALLOCED)
-                Free(c);
-        }
+/* This is an internal function that should not be used in applications.
+ * It ensures that 'b' has enough room for a 'words' word number number.
+ * It is mostly used by the various BIGNUM routines. If there is an error,
+ * NULL is returned. If not, 'b' is returned. */
 
 BIGNUM *bn_expand2(BIGNUM *b, int words)
         {
@@ -389,7 +357,7 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
  * if A and B happen to share same cache line such code is going to
  * cause severe cache trashing. Both factors have severe impact on
  * performance of modern CPUs and this is the reason why this
- * particulare piece of code is #ifdefed away and replaced by more
+ * particular piece of code is #ifdefed away and replaced by more
  * "friendly" version found in #else section below. This comment
  * also applies to BN_copy function.
  *
@@ -420,7 +388,7 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
                                 A[0]=B[0];
                         case 0:
                                 /* I need the 'case 0' entry for utrix cc.
-                                 * If the optimiser is turned on, it does the
+                                 * If the optimizer is turned on, it does the
                                  * switch table by doing
                                  * a=top&7
                                  * a--;
diff --git a/src/lib/libcrypto/bn/bn_mont.c b/src/lib/libcrypto/bn/bn_mont.c
index ee0f410c22..7bb0b91223 100644
--- a/src/lib/libcrypto/bn/bn_mont.c
+++ b/src/lib/libcrypto/bn/bn_mont.c
@@ -57,25 +57,27 @@
  */
 
 /*
- * Details about Montgomery multiplication algorithms can be found at:
- * http://www.ece.orst.edu/ISL/Publications.html
- * http://www.ece.orst.edu/ISL/Koc/papers/j37acmon.pdf
+ * Details about Montgomery multiplication algorithms can be found at
+ * http://security.ece.orst.edu/publications.html, e.g.
+ * http://security.ece.orst.edu/koc/papers/j37acmon.pdf and
+ * sections 3.8 and 4.2 in http://security.ece.orst.edu/koc/papers/r01rsasw.pdf
  */
 
 #include <stdio.h>
 #include "cryptlib.h"
 #include "bn_lcl.h"
 
-#define MONT_WORD
+#define MONT_WORD /* use the faster word-based algorithm */
 
 int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b,
                           BN_MONT_CTX *mont, BN_CTX *ctx)
         {
         BIGNUM *tmp,*tmp2;
 
-        tmp= &(ctx->bn[ctx->tos]);
-        tmp2= &(ctx->bn[ctx->tos]);
-        ctx->tos+=2;
+        BN_CTX_start(ctx);
+        tmp = BN_CTX_get(ctx);
+        tmp2 = BN_CTX_get(ctx);
+        if (tmp == NULL || tmp2 == NULL) goto err;
 
         bn_check_top(tmp);
         bn_check_top(tmp2);
@@ -99,7 +101,7 @@ int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b,
                 }
         /* reduce from aRR to aR */
         if (!BN_from_montgomery(r,tmp,mont,ctx)) goto err;
-        ctx->tos-=2;
+        BN_CTX_end(ctx);
         return(1);
 err:
         return(0);
@@ -108,160 +110,123 @@ err:
 int BN_from_montgomery(BIGNUM *ret, BIGNUM *a, BN_MONT_CTX *mont,
              BN_CTX *ctx)
         {
-#ifdef BN_RECURSION_MONT
-        if (mont->use_word)
-#endif
-                {
-                BIGNUM *n,*r;
-                BN_ULONG *ap,*np,*rp,n0,v,*nrp;
-                int al,nl,max,i,x,ri;
-                int retn=0;
+        int retn=0;
 
-                r= &(ctx->bn[ctx->tos]);
+#ifdef MONT_WORD
+        BIGNUM *n,*r;
+        BN_ULONG *ap,*np,*rp,n0,v,*nrp;
+        int al,nl,max,i,x,ri;
 
-                if (!BN_copy(r,a)) goto err1;
-                n= &(mont->N);
+        BN_CTX_start(ctx);
+        if ((r = BN_CTX_get(ctx)) == NULL) goto err;
 
-                ap=a->d;
-                /* mont->ri is the size of mont->N in bits/words */
-                al=ri=mont->ri/BN_BITS2;
+        if (!BN_copy(r,a)) goto err;
+        n= &(mont->N);
 
-                nl=n->top;
-                if ((al == 0) || (nl == 0)) { r->top=0; return(1); }
+        ap=a->d;
+        /* mont->ri is the size of mont->N in bits (rounded up
+           to the word size) */
+        al=ri=mont->ri/BN_BITS2;
+        
+        nl=n->top;
+        if ((al == 0) || (nl == 0)) { r->top=0; return(1); }
 
-                max=(nl+al+1); /* allow for overflow (no?) XXX */
-                if (bn_wexpand(r,max) == NULL) goto err1;
-                if (bn_wexpand(ret,max) == NULL) goto err1;
+        max=(nl+al+1); /* allow for overflow (no?) XXX */
+        if (bn_wexpand(r,max) == NULL) goto err;
+        if (bn_wexpand(ret,max) == NULL) goto err;
 
-                r->neg=a->neg^n->neg;
-                np=n->d;
-                rp=r->d;
-                nrp= &(r->d[nl]);
+        r->neg=a->neg^n->neg;
+        np=n->d;
+        rp=r->d;
+        nrp= &(r->d[nl]);
 
-                /* clear the top words of T */
+        /* clear the top words of T */
 #if 1
-                for (i=r->top; i<max; i++) /* memset? XXX */
-                        r->d[i]=0;
+        for (i=r->top; i<max; i++) /* memset? XXX */
+                r->d[i]=0;
 #else
-                memset(&(r->d[r->top]),0,(max-r->top)*sizeof(BN_ULONG)); 
+        memset(&(r->d[r->top]),0,(max-r->top)*sizeof(BN_ULONG)); 
 #endif
 
-                r->top=max;
-                n0=mont->n0;
+        r->top=max;
+        n0=mont->n0;
 
 #ifdef BN_COUNT
-printf("word BN_from_montgomery %d * %d\n",nl,nl);
+        printf("word BN_from_montgomery %d * %d\n",nl,nl);
 #endif
-                for (i=0; i<nl; i++)
-                        {
-                        v=bn_mul_add_words(rp,np,nl,(rp[0]*n0)&BN_MASK2);
-                        nrp++;
-                        rp++;
-                        if (((nrp[-1]+=v)&BN_MASK2) >= v)
-                                continue;
-                        else
-                                {
-                                if (((++nrp[0])&BN_MASK2) != 0) continue;
-                                if (((++nrp[1])&BN_MASK2) != 0) continue;
-                                for (x=2; (((++nrp[x])&BN_MASK2) == 0); x++) ;
-                                }
-                        }
-                bn_fix_top(r);
-
-                /* mont->ri will be a multiple of the word size */
-#if 0
-                BN_rshift(ret,r,mont->ri);
-#else
-                x=ri;
-                rp=ret->d;
-                ap= &(r->d[x]);
-                if (r->top < x)
-                        al=0;
+        for (i=0; i<nl; i++)
+                {
+                v=bn_mul_add_words(rp,np,nl,(rp[0]*n0)&BN_MASK2);
+                nrp++;
+                rp++;
+                if (((nrp[-1]+=v)&BN_MASK2) >= v)
+                        continue;
                 else
-                        al=r->top-x;
-                ret->top=al;
-                al-=4;
-                for (i=0; i<al; i+=4)
                         {
-                        BN_ULONG t1,t2,t3,t4;
-
-                        t1=ap[i+0];
-                        t2=ap[i+1];
-                        t3=ap[i+2];
-                        t4=ap[i+3];
-                        rp[i+0]=t1;
-                        rp[i+1]=t2;
-                        rp[i+2]=t3;
-                        rp[i+3]=t4;
+                        if (((++nrp[0])&BN_MASK2) != 0) continue;
+                        if (((++nrp[1])&BN_MASK2) != 0) continue;
+                        for (x=2; (((++nrp[x])&BN_MASK2) == 0); x++) ;
                         }
-                al+=4;
-                for (; i<al; i++)
-                        rp[i]=ap[i];
-#endif
-
-                if (BN_ucmp(ret, &(mont->N)) >= 0)
-                        {
-                        BN_usub(ret,ret,&(mont->N)); /* XXX */
-                        }
-                retn=1;
-err1:
-                return(retn);
                 }
-#ifdef BN_RECURSION_MONT
-        else /* bignum version */ 
+        bn_fix_top(r);
+        
+        /* mont->ri will be a multiple of the word size */
+#if 0
+        BN_rshift(ret,r,mont->ri);
+#else
+        x=ri;
+        rp=ret->d;
+        ap= &(r->d[x]);
+        if (r->top < x)
+                al=0;
+        else
+                al=r->top-x;
+        ret->top=al;
+        al-=4;
+        for (i=0; i<al; i+=4)
                 {
-                BIGNUM *t1,*t2,*t3;
-                int j,i;
-
-#ifdef BN_COUNT
-printf("number BN_from_montgomery\n");
-#endif
-
-                t1= &(ctx->bn[ctx->tos]);
-                t2= &(ctx->bn[ctx->tos+1]);
-                t3= &(ctx->bn[ctx->tos+2]);
-
-                i=mont->Ni.top;
-                bn_wexpand(ret,i); /* perhaps only i*2 */
-                bn_wexpand(t1,i*4); /* perhaps only i*2 */
-                bn_wexpand(t2,i*2); /* perhaps only i   */
-
-                bn_mul_low_recursive(t2->d,a->d,mont->Ni.d,i,t1->d);
-
-                BN_zero(t3);
-                BN_set_bit(t3,mont->N.top*BN_BITS2);
-                bn_sub_words(t3->d,t3->d,a->d,i);
-                bn_mul_high(ret->d,t2->d,mont->N.d,t3->d,i,t1->d);
-
-                /* hmm... if a is between i and 2*i, things are bad */
-                if (a->top > i)
-                        {
-                        j=(int)(bn_add_words(ret->d,ret->d,&(a->d[i]),i));
-                        if (j) /* overflow */
-                                bn_sub_words(ret->d,ret->d,mont->N.d,i);
-                        }
-                ret->top=i;
-                bn_fix_top(ret);
-                if (a->d[0])
-                        BN_add_word(ret,1); /* Always? */
-                else    /* Very very rare */
-                        {
-                        for (i=1; i<mont->N.top-1; i++)
-                                {
-                                if (a->d[i])
-                                        {
-                                        BN_add_word(ret,1); /* Always? */
-                                        break;
-                                        }
-                                }
-                        }
-
-                if (BN_ucmp(ret,&(mont->N)) >= 0)
-                        BN_usub(ret,ret,&(mont->N));
-
-                return(1);
+                BN_ULONG t1,t2,t3,t4;
+                
+                t1=ap[i+0];
+                t2=ap[i+1];
+                t3=ap[i+2];
+                t4=ap[i+3];
+                rp[i+0]=t1;
+                rp[i+1]=t2;
+                rp[i+2]=t3;
+                rp[i+3]=t4;
                 }
+        al+=4;
+        for (; i<al; i++)
+                rp[i]=ap[i];
 #endif
+#else /* !MONT_WORD */ 
+        BIGNUM *t1,*t2;
+
+        BN_CTX_start(ctx);
+        t1 = BN_CTX_get(ctx);
+        t2 = BN_CTX_get(ctx);
+        if (t1 == NULL || t2 == NULL) goto err;
+        
+        if (!BN_copy(t1,a)) goto err;
+        BN_mask_bits(t1,mont->ri);
+
+        if (!BN_mul(t2,t1,&mont->Ni,ctx)) goto err;
+        BN_mask_bits(t2,mont->ri);
+
+        if (!BN_mul(t1,t2,&mont->N,ctx)) goto err;
+        if (!BN_add(t2,a,t1)) goto err;
+        BN_rshift(ret,t2,mont->ri);
+#endif /* MONT_WORD */
+
+        if (BN_ucmp(ret, &(mont->N)) >= 0)
+                {
+                BN_usub(ret,ret,&(mont->N));
+                }
+        retn=1;
+ err:
+        BN_CTX_end(ctx);
+        return(retn);
         }
 
 BN_MONT_CTX *BN_MONT_CTX_new(void)
@@ -278,7 +243,6 @@ BN_MONT_CTX *BN_MONT_CTX_new(void)
 
 void BN_MONT_CTX_init(BN_MONT_CTX *ctx)
         {
-        ctx->use_word=0;
         ctx->ri=0;
         BN_init(&(ctx->RR));
         BN_init(&(ctx->N));
@@ -306,85 +270,53 @@ int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx)
         R= &(mont->RR);                                 /* grab RR as a temp */
         BN_copy(&(mont->N),mod);                        /* Set N */
 
-#ifdef BN_RECURSION_MONT
-        if (mont->N.top < BN_MONT_CTX_SET_SIZE_WORD)
-#endif
+#ifdef MONT_WORD
                 {
                 BIGNUM tmod;
                 BN_ULONG buf[2];
 
-                mont->use_word=1;
-
                 mont->ri=(BN_num_bits(mod)+(BN_BITS2-1))/BN_BITS2*BN_BITS2;
                 BN_zero(R);
-                BN_set_bit(R,BN_BITS2);
-                /* I was bad, this modification of a passed variable was
-                 * breaking the multithreaded stuff :-(
-                 * z=mod->top;
-                 * mod->top=1; */
+                BN_set_bit(R,BN_BITS2);                 /* R */
 
-                buf[0]=mod->d[0];
+                buf[0]=mod->d[0]; /* tmod = N mod word size */
                 buf[1]=0;
                 tmod.d=buf;
                 tmod.top=1;
-                tmod.max=mod->max;
+                tmod.max=2;
                 tmod.neg=mod->neg;
-
+                                                        /* Ri = R^-1 mod N*/
                 if ((BN_mod_inverse(&Ri,R,&tmod,ctx)) == NULL)
                         goto err;
-                BN_lshift(&Ri,&Ri,BN_BITS2);                    /* R*Ri */
+                BN_lshift(&Ri,&Ri,BN_BITS2);            /* R*Ri */
                 if (!BN_is_zero(&Ri))
-                        {
-#if 1
                         BN_sub_word(&Ri,1);
-#else
-                        BN_usub(&Ri,&Ri,BN_value_one());        /* R*Ri - 1 */
-#endif
-                        }
-                else
-                        {
-                        /* This is not common..., 1 in BN_MASK2,
-                         * It happens when buf[0] was == 1.  So for 8 bit,
-                         * this is 1/256, 16bit, 1 in 2^16 etc.
-                         */
-                        BN_set_word(&Ri,BN_MASK2);
-                        }
-                BN_div(&Ri,NULL,&Ri,&tmod,ctx);
+                else /* if N mod word size == 1 */
+                        BN_set_word(&Ri,BN_MASK2);  /* Ri-- (mod word size) */
+                BN_div(&Ri,NULL,&Ri,&tmod,ctx); /* Ni = (R*Ri-1)/N,
+                                                 * keep only least significant word: */
                 mont->n0=Ri.d[0];
                 BN_free(&Ri);
-                /* mod->top=z; */
                 }
-#ifdef BN_RECURSION_MONT
-        else
-                {
-                mont->use_word=0;
-                mont->ri=(BN_num_bits(mod)+(BN_BITS2-1))/BN_BITS2*BN_BITS2;
-#if 1
+#else /* !MONT_WORD */
+                { /* bignum version */
+                mont->ri=BN_num_bits(mod);
                 BN_zero(R);
-                BN_set_bit(R,mont->ri);
-#else
-                BN_lshift(R,BN_value_one(),mont->ri);   /* R */
-#endif
+                BN_set_bit(R,mont->ri);                 /* R = 2^ri */
+                                                        /* Ri = R^-1 mod N*/
                 if ((BN_mod_inverse(&Ri,R,mod,ctx)) == NULL)
                         goto err;
                 BN_lshift(&Ri,&Ri,mont->ri);            /* R*Ri */
-#if 1
                 BN_sub_word(&Ri,1);
-#else
-                BN_usub(&Ri,&Ri,BN_value_one());        /* R*Ri - 1 */
-#endif
+                                                        /* Ni = (R*Ri-1) / N */
                 BN_div(&(mont->Ni),NULL,&Ri,mod,ctx);
                 BN_free(&Ri);
                 }
 #endif
 
         /* setup RR for conversions */
-#if 1
         BN_zero(&(mont->RR));
         BN_set_bit(&(mont->RR),mont->ri*2);
-#else
-        BN_lshift(mont->RR,BN_value_one(),mont->ri*2);
-#endif
         BN_mod(&(mont->RR),&(mont->RR),&(mont->N),ctx);
 
         return(1);
@@ -399,7 +331,6 @@ BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from)
         BN_copy(&(to->RR),&(from->RR));
         BN_copy(&(to->N),&(from->N));
         BN_copy(&(to->Ni),&(from->Ni));
-        to->use_word=from->use_word;
         to->ri=from->ri;
         to->n0=from->n0;
         return(to);
diff --git a/src/lib/libcrypto/bn/bn_mul.c b/src/lib/libcrypto/bn/bn_mul.c
index 38c47f3d1f..eb007e19e9 100644
--- a/src/lib/libcrypto/bn/bn_mul.c
+++ b/src/lib/libcrypto/bn/bn_mul.c
@@ -66,7 +66,7 @@
  * n2 must be a power of 2.
  * We multiply and return the result.
  * t must be 2*n2 words in size
- * We calulate
+ * We calculate
  * a[0]*b[0]
  * a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
  * a[1]*b[1]
@@ -78,21 +78,23 @@ void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
         unsigned int neg,zero;
         BN_ULONG ln,lo,*p;
 
-#ifdef BN_COUNT
-printf(" bn_mul_recursive %d * %d\n",n2,n2);
-#endif
-#ifdef BN_MUL_COMBA
-/*      if (n2 == 4)
+# ifdef BN_COUNT
+        printf(" bn_mul_recursive %d * %d\n",n2,n2);
+# endif
+# ifdef BN_MUL_COMBA
+#  if 0
+        if (n2 == 4)
                 {
                 bn_mul_comba4(r,a,b);
                 return;
                 }
-        else */ if (n2 == 8)
+#  endif
+        if (n2 == 8)
                 {
                 bn_mul_comba8(r,a,b);
                 return; 
                 }
-#endif
+# endif /* BN_MUL_COMBA */
         if (n2 < BN_MUL_RECURSIVE_SIZE_NORMAL)
                 {
                 /* This should not happen */
@@ -136,7 +138,7 @@ printf(" bn_mul_recursive %d * %d\n",n2,n2);
                 break;
                 }
 
-#ifdef BN_MUL_COMBA
+# ifdef BN_MUL_COMBA
         if (n == 4)
                 {
                 if (!zero)
@@ -158,7 +160,7 @@ printf(" bn_mul_recursive %d * %d\n",n2,n2);
                 bn_mul_comba8(&(r[n2]),&(a[n]),&(b[n]));
                 }
         else
-#endif
+# endif /* BN_MUL_COMBA */
                 {
                 p= &(t[n2*2]);
                 if (!zero)
@@ -219,12 +221,12 @@ void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
              int n, BN_ULONG *t)
         {
         int i,j,n2=n*2;
-        unsigned int c1;
+        unsigned int c1,c2,neg,zero;
         BN_ULONG ln,lo,*p;
 
-#ifdef BN_COUNT
-printf(" bn_mul_part_recursive %d * %d\n",tn+n,tn+n);
-#endif
+# ifdef BN_COUNT
+        printf(" bn_mul_part_recursive %d * %d\n",tn+n,tn+n);
+# endif
         if (n < 8)
                 {
                 i=tn+n;
@@ -233,17 +235,54 @@ printf(" bn_mul_part_recursive %d * %d\n",tn+n,tn+n);
                 }
 
         /* r=(a[0]-a[1])*(b[1]-b[0]) */
-        bn_sub_words(t,      a,      &(a[n]),n); /* + */
-        bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
-
-/*      if (n == 4)
+        c1=bn_cmp_words(a,&(a[n]),n);
+        c2=bn_cmp_words(&(b[n]),b,n);
+        zero=neg=0;
+        switch (c1*3+c2)
+                {
+        case -4:
+                bn_sub_words(t,      &(a[n]),a,      n); /* - */
+                bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
+                break;
+        case -3:
+                zero=1;
+                /* break; */
+        case -2:
+                bn_sub_words(t,      &(a[n]),a,      n); /* - */
+                bn_sub_words(&(t[n]),&(b[n]),b,      n); /* + */
+                neg=1;
+                break;
+        case -1:
+        case 0:
+        case 1:
+                zero=1;
+                /* break; */
+        case 2:
+                bn_sub_words(t,      a,      &(a[n]),n); /* + */
+                bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
+                neg=1;
+                break;
+        case 3:
+                zero=1;
+                /* break; */
+        case 4:
+                bn_sub_words(t,      a,      &(a[n]),n);
+                bn_sub_words(&(t[n]),&(b[n]),b,      n);
+                break;
+                }
+                /* The zero case isn't yet implemented here. The speedup
+                   would probably be negligible. */
+# if 0
+        if (n == 4)
                 {
                 bn_mul_comba4(&(t[n2]),t,&(t[n]));
                 bn_mul_comba4(r,a,b);
                 bn_mul_normal(&(r[n2]),&(a[n]),tn,&(b[n]),tn);
                 memset(&(r[n2+tn*2]),0,sizeof(BN_ULONG)*(n2-tn*2));
                 }
-        else */ if (n == 8)
+        else
+# endif
+        if (n == 8)
                 {
                 bn_mul_comba8(&(t[n2]),t,&(t[n]));
                 bn_mul_comba8(r,a,b);
@@ -308,7 +347,16 @@ printf(" bn_mul_part_recursive %d * %d\n",tn+n,tn+n);
          */
 
         c1=(int)(bn_add_words(t,r,&(r[n2]),n2));
-        c1-=(int)(bn_sub_words(&(t[n2]),t,&(t[n2]),n2));
+
+        if (neg) /* if t[32] is negative */
+                {
+                c1-=(int)(bn_sub_words(&(t[n2]),t,&(t[n2]),n2));
+                }
+        else
+                {
+                /* Might have a carry */
+                c1+=(int)(bn_add_words(&(t[n2]),&(t[n2]),t,n2));
+                }
 
         /* t[32] holds (a[0]-a[1])*(b[1]-b[0])+(a[0]*b[0])+(a[1]*b[1])
          * r[10] holds (a[0]*b[0])
@@ -345,9 +393,9 @@ void bn_mul_low_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
         {
         int n=n2/2;
 
-#ifdef BN_COUNT
-printf(" bn_mul_low_recursive %d * %d\n",n2,n2);
-#endif
+# ifdef BN_COUNT
+        printf(" bn_mul_low_recursive %d * %d\n",n2,n2);
+# endif
 
         bn_mul_recursive(r,a,b,n,&(t[0]));
         if (n >= BN_MUL_LOW_RECURSIVE_SIZE_NORMAL)
@@ -379,9 +427,9 @@ void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l, int n2,
         int neg,oneg,zero;
         BN_ULONG ll,lc,*lp,*mp;
 
-#ifdef BN_COUNT
-printf(" bn_mul_high %d * %d\n",n2,n2);
-#endif
+# ifdef BN_COUNT
+        printf(" bn_mul_high %d * %d\n",n2,n2);
+# endif
         n=n2/2;
 
         /* Calculate (al-ah)*(bh-bl) */
@@ -424,14 +472,14 @@ printf(" bn_mul_high %d * %d\n",n2,n2);
         oneg=neg;
         /* t[10] = (a[0]-a[1])*(b[1]-b[0]) */
         /* r[10] = (a[1]*b[1]) */
-#ifdef BN_MUL_COMBA
+# ifdef BN_MUL_COMBA
         if (n == 8)
                 {
                 bn_mul_comba8(&(t[0]),&(r[0]),&(r[n]));
                 bn_mul_comba8(r,&(a[n]),&(b[n]));
                 }
         else
-#endif
+# endif
                 {
                 bn_mul_recursive(&(t[0]),&(r[0]),&(r[n]),n,&(t[n2]));
                 bn_mul_recursive(r,&(a[n]),&(b[n]),n,&(t[n2]));
@@ -555,19 +603,23 @@ printf(" bn_mul_high %d * %d\n",n2,n2);
                         }
                 }
         }
-#endif
+#endif /* BN_RECURSION */
 
 int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
         {
         int top,al,bl;
         BIGNUM *rr;
+        int ret = 0;
+#if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
+        int i;
+#endif
 #ifdef BN_RECURSION
         BIGNUM *t;
-        int i,j,k;
+        int j,k;
 #endif
 
 #ifdef BN_COUNT
-printf("BN_mul %d * %d\n",a->top,b->top);
+        printf("BN_mul %d * %d\n",a->top,b->top);
 #endif
 
         bn_check_top(a);
@@ -585,115 +637,99 @@ printf("BN_mul %d * %d\n",a->top,b->top);
                 }
         top=al+bl;
 
+        BN_CTX_start(ctx);
         if ((r == a) || (r == b))
-                rr= &(ctx->bn[ctx->tos+1]);
+                {
+                if ((rr = BN_CTX_get(ctx)) == NULL) goto err;
+                }
         else
-                rr=r;
+                rr = r;
 
 #if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
-        if (al == bl)
+        i = al-bl;
+#endif
+#ifdef BN_MUL_COMBA
+        if (i == 0)
                 {
-#  ifdef BN_MUL_COMBA
-/*              if (al == 4)
+# if 0
+                if (al == 4)
                         {
-                        if (bn_wexpand(rr,8) == NULL) return(0);
+                        if (bn_wexpand(rr,8) == NULL) goto err;
                         rr->top=8;
                         bn_mul_comba4(rr->d,a->d,b->d);
                         goto end;
                         }
-                else */ if (al == 8)
+# endif
+                if (al == 8)
                         {
-                        if (bn_wexpand(rr,16) == NULL) return(0);
+                        if (bn_wexpand(rr,16) == NULL) goto err;
                         rr->top=16;
                         bn_mul_comba8(rr->d,a->d,b->d);
                         goto end;
                         }
-                else
-#  endif
-#ifdef BN_RECURSION
-                if (al < BN_MULL_SIZE_NORMAL)
-#endif
-                        {
-                        if (bn_wexpand(rr,top) == NULL) return(0);
-                        rr->top=top;
-                        bn_mul_normal(rr->d,a->d,al,b->d,bl);
-                        goto end;
-                        }
-#  ifdef BN_RECURSION
-                goto symetric;
-#  endif
                 }
-#endif
+#endif /* BN_MUL_COMBA */
 #ifdef BN_RECURSION
-        else if ((al < BN_MULL_SIZE_NORMAL) || (bl < BN_MULL_SIZE_NORMAL))
+        if ((al >= BN_MULL_SIZE_NORMAL) && (bl >= BN_MULL_SIZE_NORMAL))
                 {
-                if (bn_wexpand(rr,top) == NULL) return(0);
-                rr->top=top;
-                bn_mul_normal(rr->d,a->d,al,b->d,bl);
-                goto end;
-                }
-        else
-                {
-                i=(al-bl);
-                if ((i ==  1) && !BN_get_flags(b,BN_FLG_STATIC_DATA))
+                if (i == 1 && !BN_get_flags(b,BN_FLG_STATIC_DATA))
                         {
                         bn_wexpand(b,al);
                         b->d[bl]=0;
                         bl++;
-                        goto symetric;
+                        i--;
                         }
-                else if ((i ==  -1) && !BN_get_flags(a,BN_FLG_STATIC_DATA))
+                else if (i == -1 && !BN_get_flags(a,BN_FLG_STATIC_DATA))
                         {
                         bn_wexpand(a,bl);
                         a->d[al]=0;
                         al++;
-                        goto symetric;
+                        i++;
+                        }
+                if (i == 0)
+                        {
+                        /* symmetric and > 4 */
+                        /* 16 or larger */
+                        j=BN_num_bits_word((BN_ULONG)al);
+                        j=1<<(j-1);
+                        k=j+j;
+                        t = BN_CTX_get(ctx);
+                        if (al == j) /* exact multiple */
+                                {
+                                bn_wexpand(t,k*2);
+                                bn_wexpand(rr,k*2);
+                                bn_mul_recursive(rr->d,a->d,b->d,al,t->d);
+                                }
+                        else
+                                {
+                                bn_wexpand(a,k);
+                                bn_wexpand(b,k);
+                                bn_wexpand(t,k*4);
+                                bn_wexpand(rr,k*4);
+                                for (i=a->top; i<k; i++)
+                                        a->d[i]=0;
+                                for (i=b->top; i<k; i++)
+                                        b->d[i]=0;
+                                bn_mul_part_recursive(rr->d,a->d,b->d,al-j,j,t->d);
+                                }
+                        rr->top=top;
+                        goto end;
                         }
                 }
-#endif
-
-        /* asymetric and >= 4 */ 
-        if (bn_wexpand(rr,top) == NULL) return(0);
+#endif /* BN_RECURSION */
+        if (bn_wexpand(rr,top) == NULL) goto err;
         rr->top=top;
         bn_mul_normal(rr->d,a->d,al,b->d,bl);
 
-#ifdef BN_RECURSION
-        if (0)
-                {
-symetric:
-                /* symetric and > 4 */
-                /* 16 or larger */
-                j=BN_num_bits_word((BN_ULONG)al);
-                j=1<<(j-1);
-                k=j+j;
-                t= &(ctx->bn[ctx->tos]);
-                if (al == j) /* exact multiple */
-                        {
-                        bn_wexpand(t,k*2);
-                        bn_wexpand(rr,k*2);
-                        bn_mul_recursive(rr->d,a->d,b->d,al,t->d);
-                        }
-                else
-                        {
-                        bn_wexpand(a,k);
-                        bn_wexpand(b,k);
-                        bn_wexpand(t,k*4);
-                        bn_wexpand(rr,k*4);
-                        for (i=a->top; i<k; i++)
-                                a->d[i]=0;
-                        for (i=b->top; i<k; i++)
-                                b->d[i]=0;
-                        bn_mul_part_recursive(rr->d,a->d,b->d,al-j,j,t->d);
-                        }
-                rr->top=top;
-                }
-#endif
 #if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
 end:
 #endif
         bn_fix_top(rr);
         if (r != rr) BN_copy(r,rr);
-        return(1);
+        ret=1;
+err:
+        BN_CTX_end(ctx);
+        return(ret);
         }
 
 void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
@@ -701,7 +737,7 @@ void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
         BN_ULONG *rr;
 
 #ifdef BN_COUNT
-printf(" bn_mul_normal %d * %d\n",na,nb);
+        printf(" bn_mul_normal %d * %d\n",na,nb);
 #endif
 
         if (na < nb)
@@ -735,7 +771,7 @@ printf(" bn_mul_normal %d * %d\n",na,nb);
 void bn_mul_low_normal(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
         {
 #ifdef BN_COUNT
-printf(" bn_mul_low_normal %d * %d\n",n,n);
+        printf(" bn_mul_low_normal %d * %d\n",n,n);
 #endif
         bn_mul_words(r,a,n,b[0]);
 
@@ -753,4 +789,3 @@ printf(" bn_mul_low_normal %d * %d\n",n,n);
                 b+=4;
                 }
         }
-
diff --git a/src/lib/libcrypto/bn/bn_opts.c b/src/lib/libcrypto/bn/bn_opts.c
index 381be529b2..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/bn_opts.c
+++ b/src/lib/libcrypto/bn/bn_opts.c
@@ -1,324 +0,0 @@
-/* crypto/bn/expspeed.c */
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-/* most of this code has been pilfered from my libdes speed.c program */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <signal.h>
-#include <string.h>
-#include <openssl/crypto.h>
-#include <openssl/tmdiff.h>
-#include <openssl/bn.h>
-#include <openssl/err.h>
-
-#define DEFAULT_SIZE    512
-#define DEFAULT_TIME    3
-
-int verbose=1;
-
-typedef struct parms_st
-        {
-        char *name;
-        void (*func)();
-        BIGNUM r;
-        BIGNUM a;
-        BIGNUM b;
-        BIGNUM c;
-        BIGNUM low;
-        BN_CTX *ctx;
-        BN_MONT_CTX *mont;
-        int w;
-        } PARMS;
-
-void do_mul_exp(int num,PARMS *p);
-void do_mul(int num,PARMS *p);
-void do_sqr(int num,PARMS *p);
-void do_mul_low(int num,PARMS *p);
-void do_mul_high(int num,PARMS *p);
-void do_from_montgomery(int num,PARMS *p);
-int time_it(int sec, PARMS *p);
-void do_it(int sec, PARMS *p);
-
-#define P_EXP   1
-#define P_MUL   2
-#define P_SQR   3
-#define P_MULL  4
-#define P_MULH  5
-#define P_MRED  6
-
-int main(int argc, char **argv)
-        {
-        PARMS p;
-        BN_MONT_CTX *mont;
-        int size=0,num;
-        char *name;
-        int type=P_EXP;
-
-        mont=BN_MONT_CTX_new();
-        p.mont=NULL;
-        p.ctx=BN_CTX_new();
-        BN_init(&p.r);
-        BN_init(&p.a);
-        BN_init(&p.b);
-        BN_init(&p.c);
-        BN_init(&p.low);
-        p.w=0;
-
-        for (;;)
-                {
-                if (argc > 1)
-                        {
-                        if (argv[1][0] == '-')
-                                {
-                                switch(argv[1][1])
-                                        {
-                                case 'e': type=P_EXP; break;
-                                case 'm': type=P_MUL; break;
-                                case 's': type=P_SQR; break;
-                                case 'l': type=P_MULL; break;
-                                case 'h': type=P_MULH; break;
-                                case 'r': type=P_MRED; break;
-                                default:
-                                        fprintf(stderr,"options: -[emslhr]\n");
-                                        exit(1);
-                                        }
-                                }
-                        else
-                                {
-                                size=atoi(argv[1]);
-                                }
-                        argc--;
-                        argv++;
-                        }
-                else
-                        break;
-                }
-        if (size == 0)
-                size=DEFAULT_SIZE;
-
-        printf("bit size:%5d\n",size);
-
-        BN_rand(&p.a,size,1,0);
-        BN_rand(&p.b,size,1,0);
-        BN_rand(&p.c,size,1,1);
-        BN_mod(&p.a,&p.a,&p.c,p.ctx);
-        BN_mod(&p.b,&p.b,&p.c,p.ctx);
-        p.w=(p.a.top+1)/2;
-
-        BN_mul(&p.low,&p.a,&p.b,p.ctx);
-        p.low.top=p.a.top;
-        
-        switch(type)
-                {
-        case P_EXP:
-                p.name="r=a^b%c";
-                p.func=do_mul_exp;
-                p.mont=mont;
-                break;
-        case P_MUL:
-                p.name="r=a*b";
-                p.func=do_mul;
-                break;
-        case P_SQR:
-                p.name="r=a*a";
-                p.func=do_sqr;
-                break;
-        case P_MULL:
-                p.name="r=low(a*b)";
-                p.func=do_mul_low;
-                break;
-        case P_MULH:
-                p.name="r=high(a*b)";
-                p.func=do_mul_high;
-                break;
-        case P_MRED:
-                p.name="r=montgomery_reduction(a)";
-                p.func=do_from_montgomery;
-                p.mont=mont;
-                break;
-        default:
-                fprintf(stderr,"options: -[emslhr]\n");
-                exit(1);
-                }
-
-        num=time_it(DEFAULT_TIME,&p);
-        do_it(num,&p);
-        }
-
-void do_it(int num, PARMS *p)
-        {
-        char *start,*end;
-        int i,j,number;
-        double d;
-
-        start=ms_time_new();
-        end=ms_time_new();
-
-        number=BN_num_bits_word((BN_ULONG)BN_num_bits(&(p->c)))-
-                BN_num_bits_word(BN_BITS2)+2;
-        for (i=number-1; i >=0; i--)
-                {
-                if (i == 1) continue;
-                BN_set_params(i,i,i,1);
-                if (p->mont != NULL)
-                        BN_MONT_CTX_set(p->mont,&(p->c),p->ctx);
-
-                printf("Timing %5d (%2d bit) %2d %2d %2d %2d :",
-                        (1<<i)*BN_BITS2,i,
-                                BN_get_params(0),
-                                BN_get_params(1),
-                                BN_get_params(2),
-                                BN_get_params(3));
-                fflush(stdout);
-
-                ms_time_get(start);
-                p->func(num,p);
-                ms_time_get(end);
-                d=ms_time_diff(start,end);
-                printf("%6.6f sec, or %d in %.4f seconds\n",
-                        (double)d/num,num,d);
-                }
-        }
-
-int time_it(int sec, PARMS *p)
-        {
-        char *start,*end;
-        int i,j;
-        double d;
-
-        if (p->mont != NULL)
-                BN_MONT_CTX_set(p->mont,&(p->c),p->ctx);
-
-        start=ms_time_new();
-        end=ms_time_new();
-
-        i=1;
-        for (;;)
-                {
-                if (verbose)
-                        printf("timing %s for %d interations\n",p->name,i);
-
-                ms_time_get(start);
-                p->func(i,p);
-                ms_time_get(end);
-                d=ms_time_diff(start,end);
-
-                if      (d < 0.01) i*=100;
-                else if (d < 0.1 ) i*=10;
-                else if (d > (double)sec) break;
-                else
-                        {
-                        i=(int)(1.0*i*sec/d);
-                        break;
-                        }
-                }
-        if (verbose)
-                printf("using %d interations\n",i);
-        return(i);
-        }
-
-void do_mul_exp(int num, PARMS *p)
-        {
-        int i;
-
-        for (i=0; i<num; i++)
-                BN_mod_exp_mont(&(p->r),&(p->a),&(p->b),&(p->c),
-                        p->ctx,p->mont);
-        }
-
-void do_mul(int num, PARMS *p)
-        {
-        int i;
-
-        for (i=0; i<num; i++)
-                BN_mul(&(p->r),&(p->a),&(p->b),p->ctx);
-        }
-
-void do_sqr(int num, PARMS *p)
-        {
-        int i;
-
-        for (i=0; i<num; i++)
-                        BN_sqr(&(p->r),&(p->a),p->ctx);
-        }
-
-void do_mul_low(int num, PARMS *p)
-        {
-        int i;
-        
-        for (i=0; i<num; i++)
-                BN_mul_low(&(p->r),&(p->a),&(p->b),p->w,p->ctx);
-        }
-
-void do_mul_high(int num, PARMS *p)
-        {
-        int i;
-
-        for (i=0; i<num; i++)
-                BN_mul_low(&(p->r),&(p->a),&(p->b),&(p->low),p->w,p->ctx);
-        }
-
-void do_from_montgomery(int num, PARMS *p)
-        {
-        int i;
-        
-        for (i=0; i<num; i++)
-                BN_from_montgomery(&(p->r),&(p->a),p->mont,p->ctx);
-        }
-
diff --git a/src/lib/libcrypto/bn/bn_prime.c b/src/lib/libcrypto/bn/bn_prime.c
index 6fa0f9be1e..a5f01b92eb 100644
--- a/src/lib/libcrypto/bn/bn_prime.c
+++ b/src/lib/libcrypto/bn/bn_prime.c
@@ -55,6 +55,59 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
+/* ====================================================================
+ * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
 
 #include <stdio.h>
 #include <time.h>
@@ -62,26 +115,29 @@
 #include "bn_lcl.h"
 #include <openssl/rand.h>
 
-/* The quick seive algorithm approach to weeding out primes is
+/* The quick sieve algorithm approach to weeding out primes is
  * Philip Zimmermann's, as implemented in PGP.  I have had a read of
  * his comments and implemented my own version.
  */
 #include "bn_prime.h"
 
-static int witness(BIGNUM *a, BIGNUM *n, BN_CTX *ctx,BN_CTX *ctx2,
-        BN_MONT_CTX *mont);
+static int witness(BIGNUM *w, const BIGNUM *a, const BIGNUM *a1,
+        const BIGNUM *a1_odd, int k, BN_CTX *ctx, BN_MONT_CTX *mont);
 static int probable_prime(BIGNUM *rnd, int bits);
 static int probable_prime_dh(BIGNUM *rnd, int bits,
         BIGNUM *add, BIGNUM *rem, BN_CTX *ctx);
-static int probable_prime_dh_strong(BIGNUM *rnd, int bits,
+static int probable_prime_dh_safe(BIGNUM *rnd, int bits,
         BIGNUM *add, BIGNUM *rem, BN_CTX *ctx);
-BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int strong, BIGNUM *add,
+
+BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, BIGNUM *add,
              BIGNUM *rem, void (*callback)(int,int,void *), void *cb_arg)
         {
         BIGNUM *rnd=NULL;
         BIGNUM t;
+        int found=0;
         int i,j,c1=0;
         BN_CTX *ctx;
+        int checks = BN_prime_checks_for_size(bits);
 
         ctx=BN_CTX_new();
         if (ctx == NULL) goto err;
@@ -100,9 +156,9 @@ loop:
                 }
         else
                 {
-                if (strong)
+                if (safe)
                         {
-                        if (!probable_prime_dh_strong(rnd,bits,add,rem,ctx))
+                        if (!probable_prime_dh_safe(rnd,bits,add,rem,ctx))
                                  goto err;
                         }
                 else
@@ -114,160 +170,185 @@ loop:
         /* if (BN_mod_word(rnd,(BN_ULONG)3) == 1) goto loop; */
         if (callback != NULL) callback(0,c1++,cb_arg);
 
-        if (!strong)
+        if (!safe)
                 {
-                i=BN_is_prime(rnd,BN_prime_checks,callback,ctx,cb_arg);
+                i=BN_is_prime_fasttest(rnd,checks,callback,ctx,cb_arg,0);
                 if (i == -1) goto err;
                 if (i == 0) goto loop;
                 }
         else
                 {
-                /* for a strong prime generation,
+                /* for "safe prime" generation,
                  * check that (p-1)/2 is prime.
                  * Since a prime is odd, We just
                  * need to divide by 2 */
                 if (!BN_rshift1(&t,rnd)) goto err;
 
-                for (i=0; i<BN_prime_checks; i++)
+                for (i=0; i<checks; i++)
                         {
-                        j=BN_is_prime(rnd,1,callback,ctx,cb_arg);
+                        j=BN_is_prime_fasttest(rnd,1,callback,ctx,cb_arg,0);
                         if (j == -1) goto err;
                         if (j == 0) goto loop;
 
-                        j=BN_is_prime(&t,1,callback,ctx,cb_arg);
+                        j=BN_is_prime_fasttest(&t,1,callback,ctx,cb_arg,0);
                         if (j == -1) goto err;
                         if (j == 0) goto loop;
 
                         if (callback != NULL) callback(2,c1-1,cb_arg);
-                        /* We have a strong prime test pass */
+                        /* We have a safe prime test pass */
                         }
                 }
         /* we have a prime :-) */
-        ret=rnd;
+        found = 1;
 err:
-        if ((ret == NULL) && (rnd != NULL)) BN_free(rnd);
+        if (!found && (ret == NULL) && (rnd != NULL)) BN_free(rnd);
         BN_free(&t);
         if (ctx != NULL) BN_CTX_free(ctx);
-        return(ret);
+        return(found ? rnd : NULL);
         }
 
-int BN_is_prime(BIGNUM *a, int checks, void (*callback)(int,int,void *),
-             BN_CTX *ctx_passed, void *cb_arg)
+int BN_is_prime(const BIGNUM *a, int checks, void (*callback)(int,int,void *),
+        BN_CTX *ctx_passed, void *cb_arg)
         {
-        int i,j,c2=0,ret= -1;
-        BIGNUM *check;
-        BN_CTX *ctx=NULL,*ctx2=NULL;
-        BN_MONT_CTX *mont=NULL;
+        return BN_is_prime_fasttest(a, checks, callback, ctx_passed, cb_arg, 0);
+        }
 
+int BN_is_prime_fasttest(const BIGNUM *a, int checks,
+                void (*callback)(int,int,void *),
+                BN_CTX *ctx_passed, void *cb_arg,
+                int do_trial_division)
+        {
+        int i, j, ret = -1;
+        int k;
+        BN_CTX *ctx = NULL;
+        BIGNUM *A1, *A1_odd, *check; /* taken from ctx */
+        BN_MONT_CTX *mont = NULL;
+        const BIGNUM *A = NULL;
+
+        if (checks == BN_prime_checks)
+                checks = BN_prime_checks_for_size(BN_num_bits(a));
+
+        /* first look for small factors */
         if (!BN_is_odd(a))
                 return(0);
+        if (do_trial_division)
+                {
+                for (i = 1; i < NUMPRIMES; i++)
+                        if (BN_mod_word(a, primes[i]) == 0) 
+                                return 0;
+                if (callback != NULL) callback(1, -1, cb_arg);
+                }
+
         if (ctx_passed != NULL)
-                ctx=ctx_passed;
+                ctx = ctx_passed;
         else
-                if ((ctx=BN_CTX_new()) == NULL) goto err;
-
-        if ((ctx2=BN_CTX_new()) == NULL) goto err;
-        if ((mont=BN_MONT_CTX_new()) == NULL) goto err;
-
-        check= &(ctx->bn[ctx->tos++]);
+                if ((ctx=BN_CTX_new()) == NULL)
+                        goto err;
+        BN_CTX_start(ctx);
 
-        /* Setup the montgomery structure */
-        if (!BN_MONT_CTX_set(mont,a,ctx2)) goto err;
+        /* A := abs(a) */
+        if (a->neg)
+                {
+                BIGNUM *t;
+                if ((t = BN_CTX_get(ctx)) == NULL) goto err;
+                BN_copy(t, a);
+                t->neg = 0;
+                A = t;
+                }
+        else
+                A = a;
+        A1 = BN_CTX_get(ctx);
+        A1_odd = BN_CTX_get(ctx);
+        check = BN_CTX_get(ctx);
+        if (check == NULL) goto err;
+
+        /* compute A1 := A - 1 */
+        if (!BN_copy(A1, A))
+                goto err;
+        if (!BN_sub_word(A1, 1))
+                goto err;
+        if (BN_is_zero(A1))
+                {
+                ret = 0;
+                goto err;
+                }
 
-        for (i=0; i<checks; i++)
+        /* write  A1  as  A1_odd * 2^k */
+        k = 1;
+        while (!BN_is_bit_set(A1, k))
+                k++;
+        if (!BN_rshift(A1_odd, A1, k))
+                goto err;
+
+        /* Montgomery setup for computations mod A */
+        mont = BN_MONT_CTX_new();
+        if (mont == NULL)
+                goto err;
+        if (!BN_MONT_CTX_set(mont, A, ctx))
+                goto err;
+        
+        for (i = 0; i < checks; i++)
                 {
-                if (!BN_rand(check,BN_num_bits(a)-1,0,0)) goto err;
-                j=witness(check,a,ctx,ctx2,mont);
+                if (!BN_pseudo_rand(check, BN_num_bits(A1), 0, 0))
+                        goto err;
+                if (BN_cmp(check, A1) >= 0)
+                        if (!BN_sub(check, check, A1))
+                                goto err;
+                if (!BN_add_word(check, 1))
+                        goto err;
+                /* now 1 <= check < A */
+
+                j = witness(check, A, A1, A1_odd, k, ctx, mont);
                 if (j == -1) goto err;
                 if (j)
                         {
                         ret=0;
                         goto err;
                         }
-                if (callback != NULL) callback(1,c2++,cb_arg);
+                if (callback != NULL) callback(1,i,cb_arg);
                 }
         ret=1;
 err:
-        ctx->tos--;
-        if ((ctx_passed == NULL) && (ctx != NULL))
-                BN_CTX_free(ctx);
-        if (ctx2 != NULL)
-                BN_CTX_free(ctx2);
-        if (mont != NULL) BN_MONT_CTX_free(mont);
-                
+        if (ctx != NULL)
+                {
+                BN_CTX_end(ctx);
+                if (ctx_passed == NULL)
+                        BN_CTX_free(ctx);
+                }
+        if (mont != NULL)
+                BN_MONT_CTX_free(mont);
+
         return(ret);
         }
 
-#define RECP_MUL_MOD
-
-static int witness(BIGNUM *a, BIGNUM *n, BN_CTX *ctx, BN_CTX *ctx2,
-             BN_MONT_CTX *mont)
+static int witness(BIGNUM *w, const BIGNUM *a, const BIGNUM *a1,
+        const BIGNUM *a1_odd, int k, BN_CTX *ctx, BN_MONT_CTX *mont)
         {
-        int k,i,ret= -1,good;
-        BIGNUM *d,*dd,*tmp,*d1,*d2,*n1;
-        BIGNUM *mont_one,*mont_n1,*mont_a;
-
-        d1= &(ctx->bn[ctx->tos]);
-        d2= &(ctx->bn[ctx->tos+1]);
-        n1= &(ctx->bn[ctx->tos+2]);
-        ctx->tos+=3;
-
-        mont_one= &(ctx2->bn[ctx2->tos]);
-        mont_n1= &(ctx2->bn[ctx2->tos+1]);
-        mont_a= &(ctx2->bn[ctx2->tos+2]);
-        ctx2->tos+=3;
-
-        d=d1;
-        dd=d2;
-        if (!BN_one(d)) goto err;
-        if (!BN_sub(n1,n,d)) goto err; /* n1=n-1; */
-        k=BN_num_bits(n1);
-
-        if (!BN_to_montgomery(mont_one,BN_value_one(),mont,ctx2)) goto err;
-        if (!BN_to_montgomery(mont_n1,n1,mont,ctx2)) goto err;
-        if (!BN_to_montgomery(mont_a,a,mont,ctx2)) goto err;
-
-        BN_copy(d,mont_one);
-        for (i=k-1; i>=0; i--)
+        if (!BN_mod_exp_mont(w, w, a1_odd, a, ctx, mont)) /* w := w^a1_odd mod a */
+                return -1;
+        if (BN_is_one(w))
+                return 0; /* probably prime */
+        if (BN_cmp(w, a1) == 0)
+                return 0; /* w == -1 (mod a),  'a' is probably prime */
+        while (--k)
                 {
-                if (    (BN_cmp(d,mont_one) != 0) &&
-                        (BN_cmp(d,mont_n1) != 0))
-                        good=1;
-                else
-                        good=0;
-
-                BN_mod_mul_montgomery(dd,d,d,mont,ctx2);
-
-                if (good && (BN_cmp(dd,mont_one) == 0))
-                        {
-                        ret=1;
-                        goto err;
-                        }
-                if (BN_is_bit_set(n1,i))
-                        {
-                        BN_mod_mul_montgomery(d,dd,mont_a,mont,ctx2);
-                        }
-                else
-                        {
-                        tmp=d;
-                        d=dd;
-                        dd=tmp;
-                        }
+                if (!BN_mod_mul(w, w, w, a, ctx)) /* w := w^2 mod a */
+                        return -1;
+                if (BN_is_one(w))
+                        return 1; /* 'a' is composite, otherwise a previous 'w' would
+                                   * have been == -1 (mod 'a') */
+                if (BN_cmp(w, a1) == 0)
+                        return 0; /* w == -1 (mod a), 'a' is probably prime */
                 }
-        if (BN_cmp(d,mont_one) == 0)
-                i=0;
-        else    i=1;
-        ret=i;
-err:
-        ctx->tos-=3;
-        ctx2->tos-=3;
-        return(ret);
+        /* If we get here, 'w' is the (a-1)/2-th power of the original 'w',
+         * and it is neither -1 nor +1 -- so 'a' cannot be prime */
+        return 1;
         }
 
 static int probable_prime(BIGNUM *rnd, int bits)
         {
         int i;
-        MS_STATIC BN_ULONG mods[NUMPRIMES];
+        BN_ULONG mods[NUMPRIMES];
         BN_ULONG delta,d;
 
 again:
@@ -285,7 +366,7 @@ again:
                         d=delta;
                         delta+=2;
                         /* perhaps need to check for overflow of
-                         * delta (but delta can be upto 2^32)
+                         * delta (but delta can be up to 2^32)
                          * 21-May-98 eay - added overflow check */
                         if (delta < d) goto again;
                         goto loop;
@@ -301,7 +382,8 @@ static int probable_prime_dh(BIGNUM *rnd, int bits, BIGNUM *add, BIGNUM *rem,
         int i,ret=0;
         BIGNUM *t1;
 
-        t1= &(ctx->bn[ctx->tos++]);
+        BN_CTX_start(ctx);
+        if ((t1 = BN_CTX_get(ctx)) == NULL) goto err;
 
         if (!BN_rand(rnd,bits,0,1)) goto err;
 
@@ -327,20 +409,22 @@ static int probable_prime_dh(BIGNUM *rnd, int bits, BIGNUM *add, BIGNUM *rem,
                 }
         ret=1;
 err:
-        ctx->tos--;
+        BN_CTX_end(ctx);
         return(ret);
         }
 
-static int probable_prime_dh_strong(BIGNUM *p, int bits, BIGNUM *padd,
+static int probable_prime_dh_safe(BIGNUM *p, int bits, BIGNUM *padd,
              BIGNUM *rem, BN_CTX *ctx)
         {
         int i,ret=0;
-        BIGNUM *t1,*qadd=NULL,*q=NULL;
+        BIGNUM *t1,*qadd,*q;
 
         bits--;
-        t1= &(ctx->bn[ctx->tos++]);
-        q= &(ctx->bn[ctx->tos++]);
-        qadd= &(ctx->bn[ctx->tos++]);
+        BN_CTX_start(ctx);
+        t1 = BN_CTX_get(ctx);
+        q = BN_CTX_get(ctx);
+        qadd = BN_CTX_get(ctx);
+        if (qadd == NULL) goto err;
 
         if (!BN_rshift1(qadd,padd)) goto err;
                 
@@ -376,72 +460,6 @@ static int probable_prime_dh_strong(BIGNUM *p, int bits, BIGNUM *padd,
                 }
         ret=1;
 err:
-        ctx->tos-=3;
-        return(ret);
-        }
-
-#if 0
-static int witness(BIGNUM *a, BIGNUM *n, BN_CTX *ctx)
-        {
-        int k,i,nb,ret= -1;
-        BIGNUM *d,*dd,*tmp;
-        BIGNUM *d1,*d2,*x,*n1,*inv;
-
-        d1= &(ctx->bn[ctx->tos]);
-        d2= &(ctx->bn[ctx->tos+1]);
-        x=  &(ctx->bn[ctx->tos+2]);
-        n1= &(ctx->bn[ctx->tos+3]);
-        inv=&(ctx->bn[ctx->tos+4]);
-        ctx->tos+=5;
-
-        d=d1;
-        dd=d2;
-        if (!BN_one(d)) goto err;
-        if (!BN_sub(n1,n,d)) goto err; /* n1=n-1; */
-        k=BN_num_bits(n1);
-
-        /* i=BN_num_bits(n); */
-#ifdef RECP_MUL_MOD
-        nb=BN_reciprocal(inv,n,ctx); /**/
-        if (nb == -1) goto err;
-#endif
-
-        for (i=k-1; i>=0; i--)
-                {
-                if (BN_copy(x,d) == NULL) goto err;
-#ifndef RECP_MUL_MOD
-                if (!BN_mod_mul(dd,d,d,n,ctx)) goto err;
-#else
-                if (!BN_mod_mul_reciprocal(dd,d,d,n,inv,nb,ctx)) goto err;
-#endif
-                if (    BN_is_one(dd) &&
-                        !BN_is_one(x) &&
-                        (BN_cmp(x,n1) != 0))
-                        {
-                        ret=1;
-                        goto err;
-                        }
-                if (BN_is_bit_set(n1,i))
-                        {
-#ifndef RECP_MUL_MOD
-                        if (!BN_mod_mul(d,dd,a,n,ctx)) goto err;
-#else
-                        if (!BN_mod_mul_reciprocal(d,dd,a,n,inv,nb,ctx)) goto err; 
-#endif
-                        }
-                else
-                        {
-                        tmp=d;
-                        d=dd;
-                        dd=tmp;
-                        }
-                }
-        if (BN_is_one(d))
-                i=0;
-        else    i=1;
-        ret=i;
-err:
-        ctx->tos-=5;
+        BN_CTX_end(ctx);
         return(ret);
         }
-#endif
diff --git a/src/lib/libcrypto/bn/bn_prime.h b/src/lib/libcrypto/bn/bn_prime.h
index 6fce0210cd..b7cf9a9bfe 100644
--- a/src/lib/libcrypto/bn/bn_prime.h
+++ b/src/lib/libcrypto/bn/bn_prime.h
@@ -1,4 +1,4 @@
-/* crypto/bn/bn_prime.h */
+/* Auto generated by bn_prime.pl */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -61,7 +61,7 @@
 #else
 #define NUMPRIMES 54
 #endif
-static unsigned int primes[NUMPRIMES]=
+static const unsigned int primes[NUMPRIMES]=
         {
            2,   3,   5,   7,  11,  13,  17,  19,
           23,  29,  31,  37,  41,  43,  47,  53,
diff --git a/src/lib/libcrypto/bn/bn_prime.pl b/src/lib/libcrypto/bn/bn_prime.pl
index 979385a334..9fc3765486 100644
--- a/src/lib/libcrypto/bn/bn_prime.pl
+++ b/src/lib/libcrypto/bn/bn_prime.pl
@@ -18,13 +18,74 @@ loop: while ($#primes < $num-1)
         push(@primes,$p);
         }
 
-print <<"EOF";
+# print <<"EOF";
+# /* Auto generated by bn_prime.pl */
+# /* Copyright (C) 1995-1997 Eric Young (eay\@mincom.oz.au).
+#  * All rights reserved.
+#  * Copyright remains Eric Young's, and as such any Copyright notices in
+#  * the code are not to be removed.
+#  * See the COPYRIGHT file in the SSLeay distribution for more details.
+#  */
+# 
+# EOF
+
+print <<\EOF;
 /* Auto generated by bn_prime.pl */
-/* Copyright (C) 1995-1997 Eric Young (eay\@mincom.oz.au).
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ * 
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ * 
  * Copyright remains Eric Young's, and as such any Copyright notices in
  * the code are not to be removed.
- * See the COPYRIGHT file in the SSLeay distribution for more details.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from 
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * 
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
  */
 
 EOF
@@ -43,7 +104,7 @@ printf "#define NUMPRIMES %d\n",$num;
 printf "#else\n";
 printf "#define NUMPRIMES %d\n",$eight;
 printf "#endif\n";
-print "static unsigned int primes[NUMPRIMES]=\n\t{\n\t";
+print "static const unsigned int primes[NUMPRIMES]=\n\t{\n\t";
 $init=0;
 for ($i=0; $i <= $#primes; $i++)
         {
diff --git a/src/lib/libcrypto/bn/bn_print.c b/src/lib/libcrypto/bn/bn_print.c
index 2f5ab2617b..782a96e7e0 100644
--- a/src/lib/libcrypto/bn/bn_print.c
+++ b/src/lib/libcrypto/bn/bn_print.c
@@ -137,7 +137,7 @@ char *BN_bn2dec(const BIGNUM *a)
                         }
                 lp--;
                 /* We now have a series of blocks, BN_DEC_NUM chars
-                 * in length, where the last one needs trucation.
+                 * in length, where the last one needs truncation.
                  * The blocks need to be reversed in order. */
                 sprintf(p,BN_DEC_FMT1,*lp);
                 while (*p) p++;
@@ -171,7 +171,7 @@ int BN_hex2bn(BIGNUM **bn, const char *a)
         num=i+neg;
         if (bn == NULL) return(num);
 
-        /* a is the start of the hex digets, and it is 'i' long */
+        /* a is the start of the hex digits, and it is 'i' long */
         if (*bn == NULL)
                 {
                 if ((ret=BN_new()) == NULL) return(0);
@@ -185,7 +185,7 @@ int BN_hex2bn(BIGNUM **bn, const char *a)
         /* i is the number of hex digests; */
         if (bn_expand(ret,i*4) == NULL) goto err;
 
-        j=i; /* least significate 'hex' */
+        j=i; /* least significant 'hex' */
         m=0;
         h=0;
         while (j > 0)
@@ -236,8 +236,8 @@ int BN_dec2bn(BIGNUM **bn, const char *a)
         num=i+neg;
         if (bn == NULL) return(num);
 
-        /* a is the start of the digets, and it is 'i' long.
-         * We chop it into BN_DEC_NUM digets at a time */
+        /* a is the start of the digits, and it is 'i' long.
+         * We chop it into BN_DEC_NUM digits at a time */
         if (*bn == NULL)
                 {
                 if ((ret=BN_new()) == NULL) return(0);
@@ -278,9 +278,8 @@ err:
         }
 
 #ifndef NO_BIO
-
 #ifndef NO_FP_API
-int BN_print_fp(FILE *fp, BIGNUM *a)
+int BN_print_fp(FILE *fp, const BIGNUM *a)
         {
         BIO *b;
         int ret;
@@ -319,5 +318,15 @@ int BN_print(BIO *bp, const BIGNUM *a)
 end:
         return(ret);
         }
+#endif
 
+#ifdef BN_DEBUG
+void bn_dump1(FILE *o, const char *a, BN_ULONG *b,int n)
+        {
+        int i;
+        fprintf(o, "%s=", a);
+        for (i=n-1;i>=0;i--)
+                fprintf(o, "%08lX", b[i]); /* assumes 32-bit BN_ULONG */
+        fprintf(o, "\n");
+        }
 #endif
diff --git a/src/lib/libcrypto/bn/bn_rand.c b/src/lib/libcrypto/bn/bn_rand.c
index 91b8e34ae6..943712c15b 100644
--- a/src/lib/libcrypto/bn/bn_rand.c
+++ b/src/lib/libcrypto/bn/bn_rand.c
@@ -62,7 +62,7 @@
 #include "bn_lcl.h"
 #include <openssl/rand.h>
 
-int BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
+static int bnrand(int pseudorand, BIGNUM *rnd, int bits, int top, int bottom)
         {
         unsigned char *buf=NULL;
         int ret=0,bit,bytes,mask;
@@ -81,9 +81,19 @@ int BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
 
         /* make a random number and set the top and bottom bits */
         time(&tim);
-        RAND_seed(&tim,sizeof(tim));
+        RAND_add(&tim,sizeof(tim),0);
+
+        if (pseudorand)
+                {
+                if (RAND_pseudo_bytes(buf, bytes) == -1)
+                        goto err;
+                }
+        else
+                {
+                if (RAND_bytes(buf, bytes) <= 0)
+                        goto err;
+                }
 
-        RAND_bytes(buf,(int)bytes);
         if (top)
                 {
                 if (bit == 0)
@@ -115,3 +125,12 @@ err:
         return(ret);
         }
 
+int     BN_rand(BIGNUM *rnd, int bits, int top, int bottom)
+        {
+        return bnrand(0, rnd, bits, top, bottom);
+        }
+
+int     BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom)
+        {
+        return bnrand(1, rnd, bits, top, bottom);
+        }
diff --git a/src/lib/libcrypto/bn/bn_recp.c b/src/lib/libcrypto/bn/bn_recp.c
index c1b0e230ea..a8796bd0aa 100644
--- a/src/lib/libcrypto/bn/bn_recp.c
+++ b/src/lib/libcrypto/bn/bn_recp.c
@@ -106,7 +106,8 @@ int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *x, BIGNUM *y, BN_RECP_CTX *recp,
         int ret=0;
         BIGNUM *a;
 
-        a= &(ctx->bn[ctx->tos++]);
+        BN_CTX_start(ctx);
+        if ((a = BN_CTX_get(ctx)) == NULL) goto err;
         if (y != NULL)
                 {
                 if (x == y)
@@ -120,33 +121,34 @@ int BN_mod_mul_reciprocal(BIGNUM *r, BIGNUM *x, BIGNUM *y, BN_RECP_CTX *recp,
         BN_div_recp(NULL,r,a,recp,ctx);
         ret=1;
 err:
-        ctx->tos--;
+        BN_CTX_end(ctx);
         return(ret);
         }
 
 int BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BN_RECP_CTX *recp,
              BN_CTX *ctx)
         {
-        int i,j,tos,ret=0,ex;
+        int i,j,ret=0;
         BIGNUM *a,*b,*d,*r;
 
-        tos=ctx->tos;
-        a= &(ctx->bn[ctx->tos++]);
-        b= &(ctx->bn[ctx->tos++]);
+        BN_CTX_start(ctx);
+        a=BN_CTX_get(ctx);
+        b=BN_CTX_get(ctx);
         if (dv != NULL)
                 d=dv;
         else
-                d= &(ctx->bn[ctx->tos++]);
+                d=BN_CTX_get(ctx);
         if (rem != NULL)
                 r=rem;
         else
-                r= &(ctx->bn[ctx->tos++]);
+                r=BN_CTX_get(ctx);
+        if (a == NULL || b == NULL || d == NULL || r == NULL) goto err;
 
         if (BN_ucmp(m,&(recp->N)) < 0)
                 {
                 BN_zero(d);
                 BN_copy(r,m);
-                ctx->tos=tos;
+                BN_CTX_end(ctx);
                 return(1);
                 }
 
@@ -157,33 +159,24 @@ int BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BN_RECP_CTX *recp,
          */
         i=BN_num_bits(m);
 
-        j=recp->num_bits*2;
-        if (j > i)
-                {
-                i=j;
-                ex=0;
-                }
-        else
-                {
-                ex=(i-j)/2;
-                }
-
-        j=i/2;
+        j=recp->num_bits<<1;
+        if (j>i) i=j;
+        j>>=1;
 
         if (i != recp->shift)
                 recp->shift=BN_reciprocal(&(recp->Nr),&(recp->N),
                         i,ctx);
 
-        if (!BN_rshift(a,m,j-ex)) goto err;
+        if (!BN_rshift(a,m,j)) goto err;
         if (!BN_mul(b,a,&(recp->Nr),ctx)) goto err;
-        if (!BN_rshift(d,b,j+ex)) goto err;
+        if (!BN_rshift(d,b,i-j)) goto err;
         d->neg=0;
         if (!BN_mul(b,&(recp->N),d,ctx)) goto err;
         if (!BN_usub(r,m,b)) goto err;
         r->neg=0;
 
-        j=0;
 #if 1
+        j=0;
         while (BN_ucmp(r,&(recp->N)) >= 0)
                 {
                 if (j++ > 2)
@@ -200,7 +193,7 @@ int BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BN_RECP_CTX *recp,
         d->neg=m->neg^recp->N.neg;
         ret=1;
 err:
-        ctx->tos=tos;
+        BN_CTX_end(ctx);
         return(ret);
         } 
 
diff --git a/src/lib/libcrypto/bn/bn_sqr.c b/src/lib/libcrypto/bn/bn_sqr.c
index 12cce4d7ce..fe00c5f69a 100644
--- a/src/lib/libcrypto/bn/bn_sqr.c
+++ b/src/lib/libcrypto/bn/bn_sqr.c
@@ -65,14 +65,13 @@
 int BN_sqr(BIGNUM *r, BIGNUM *a, BN_CTX *ctx)
         {
         int max,al;
+        int ret = 0;
         BIGNUM *tmp,*rr;
 
 #ifdef BN_COUNT
 printf("BN_sqr %d * %d\n",a->top,a->top);
 #endif
         bn_check_top(a);
-        tmp= &(ctx->bn[ctx->tos]);
-        rr=(a != r)?r: (&ctx->bn[ctx->tos+1]);
 
         al=a->top;
         if (al <= 0)
@@ -81,8 +80,13 @@ printf("BN_sqr %d * %d\n",a->top,a->top);
                 return(1);
                 }
 
+        BN_CTX_start(ctx);
+        rr=(a != r) ? r : BN_CTX_get(ctx);
+        tmp=BN_CTX_get(ctx);
+        if (tmp == NULL) goto err;
+
         max=(al+al);
-        if (bn_wexpand(rr,max+1) == NULL) return(0);
+        if (bn_wexpand(rr,max+1) == NULL) goto err;
 
         r->neg=0;
         if (al == 4)
@@ -120,18 +124,18 @@ printf("BN_sqr %d * %d\n",a->top,a->top);
                         k=j+j;
                         if (al == j)
                                 {
-                                if (bn_wexpand(a,k*2) == NULL) return(0);
-                                if (bn_wexpand(tmp,k*2) == NULL) return(0);
+                                if (bn_wexpand(a,k*2) == NULL) goto err;
+                                if (bn_wexpand(tmp,k*2) == NULL) goto err;
                                 bn_sqr_recursive(rr->d,a->d,al,tmp->d);
                                 }
                         else
                                 {
-                                if (bn_wexpand(tmp,max) == NULL) return(0);
+                                if (bn_wexpand(tmp,max) == NULL) goto err;
                                 bn_sqr_normal(rr->d,a->d,al,tmp->d);
                                 }
                         }
 #else
-                if (bn_wexpand(tmp,max) == NULL) return(0);
+                if (bn_wexpand(tmp,max) == NULL) goto err;
                 bn_sqr_normal(rr->d,a->d,al,tmp->d);
 #endif
                 }
@@ -139,7 +143,10 @@ printf("BN_sqr %d * %d\n",a->top,a->top);
         rr->top=max;
         if ((max > 0) && (rr->d[max-1] == 0)) rr->top--;
         if (rr != r) BN_copy(r,rr);
-        return(1);
+        ret = 1;
+ err:
+        BN_CTX_end(ctx);
+        return(ret);
         }
 
 /* tmp must have 2*n words */
@@ -185,7 +192,7 @@ void bn_sqr_normal(BN_ULONG *r, BN_ULONG *a, int n, BN_ULONG *tmp)
  * n must be a power of 2.
  * We multiply and return the result.
  * t must be 2*n words in size
- * We calulate
+ * We calculate
  * a[0]*b[0]
  * a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
  * a[1]*b[1]
diff --git a/src/lib/libcrypto/bn/bn_word.c b/src/lib/libcrypto/bn/bn_word.c
index c0cfbc6797..73157a7d43 100644
--- a/src/lib/libcrypto/bn/bn_word.c
+++ b/src/lib/libcrypto/bn/bn_word.c
@@ -60,7 +60,7 @@
 #include "cryptlib.h"
 #include "bn_lcl.h"
 
-BN_ULONG BN_mod_word(BIGNUM *a, BN_ULONG w)
+BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w)
         {
 #ifndef BN_LLONG
         BN_ULONG ret=0;
diff --git a/src/lib/libcrypto/bn/bnspeed.c b/src/lib/libcrypto/bn/bnspeed.c
index 0922aa3e16..20fc7e08ff 100644
--- a/src/lib/libcrypto/bn/bnspeed.c
+++ b/src/lib/libcrypto/bn/bnspeed.c
@@ -1,3 +1,5 @@
+/* unused */
+
 /* crypto/bn/bnspeed.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
diff --git a/src/lib/libcrypto/bn/bntest.c b/src/lib/libcrypto/bn/bntest.c
index df4b81f5b2..41c22f5954 100644
--- a/src/lib/libcrypto/bn/bntest.c
+++ b/src/lib/libcrypto/bn/bntest.c
@@ -72,6 +72,10 @@
 #include "../bio/bss_file.c"
 #endif
 
+const int num0 = 100; /* number of tests */
+const int num1 = 50;  /* additional tests for some functions */
+const int num2 = 5;   /* number of tests for slow functions */
+
 int test_add(BIO *bp);
 int test_sub(BIO *bp);
 int test_lshift1(BIO *bp);
@@ -95,15 +99,33 @@ static int results=0;
 #include "bss_file.c"
 #endif
 
-static unsigned char lst1[]="\xC6\x4F\x43\x04\x2A\xEA\xCA\x6E\x58\x36\x80\x5B\xE8\xC9"
+static unsigned char lst[]="\xC6\x4F\x43\x04\x2A\xEA\xCA\x6E\x58\x36\x80\x5B\xE8\xC9"
 "\x9B\x04\x5D\x48\x36\xC2\xFD\x16\xC9\x64\xF0";
 
+static const char rnd_seed[] = "string to make the random number generator think it has entropy";
+
+static void message(BIO *out, char *m)
+        {
+        fprintf(stderr, "test %s\n", m);
+#if defined(linux) || defined(__FreeBSD__) /* can we use GNU bc features? */
+        BIO_puts(out, "print \"test ");
+        BIO_puts(out, m);
+        BIO_puts(out, "\\n\"\n");
+#endif
+        }
+
 int main(int argc, char *argv[])
         {
         BN_CTX *ctx;
         BIO *out;
         char *outfile=NULL;
 
+        results = 0;
+
+        RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_rand may fail, and we don't
+                                               * even check its return value
+                                               * (which we should) */
+
         argc--;
         argv++;
         while (argc >= 1)
@@ -141,78 +163,81 @@ int main(int argc, char *argv[])
         if (!results)
                 BIO_puts(out,"obase=16\nibase=16\n");
 
-        fprintf(stderr,"test BN_add\n");
+        message(out,"BN_add");
         if (!test_add(out)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_sub\n");
+        message(out,"BN_sub");
         if (!test_sub(out)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_lshift1\n");
+        message(out,"BN_lshift1");
         if (!test_lshift1(out)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_lshift (fixed)\n");
-        if (!test_lshift(out,ctx,BN_bin2bn(lst1,sizeof(lst1)-1,NULL)))
+        message(out,"BN_lshift (fixed)");
+        if (!test_lshift(out,ctx,BN_bin2bn(lst,sizeof(lst)-1,NULL)))
             goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_lshift\n");
+        message(out,"BN_lshift");
         if (!test_lshift(out,ctx,NULL)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_rshift1\n");
+        message(out,"BN_rshift1");
         if (!test_rshift1(out)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_rshift\n");
+        message(out,"BN_rshift");
         if (!test_rshift(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_sqr\n");
+        message(out,"BN_sqr");
         if (!test_sqr(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_mul\n");
+        message(out,"BN_mul");
         if (!test_mul(out)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_div\n");
+        message(out,"BN_div");
         if (!test_div(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_div_recp\n");
+        message(out,"BN_div_recp");
         if (!test_div_recp(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_mod\n");
+        message(out,"BN_mod");
         if (!test_mod(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_mod_mul\n");
+        message(out,"BN_mod_mul");
         if (!test_mod_mul(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-/*
-        fprintf(stderr,"test BN_mont\n");
+        message(out,"BN_mont");
         if (!test_mont(out,ctx)) goto err;
-        fflush(stdout);
-*/
-        fprintf(stderr,"test BN_mod_exp\n");
+        BIO_flush(out);
+
+        message(out,"BN_mod_exp");
         if (!test_mod_exp(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
 
-        fprintf(stderr,"test BN_exp\n");
+        message(out,"BN_exp");
         if (!test_exp(out,ctx)) goto err;
-        fflush(stdout);
+        BIO_flush(out);
+
+        BN_CTX_free(ctx);
+        BIO_free(out);
 
 /**/
         exit(0);
 err:
         BIO_puts(out,"1\n"); /* make sure bc fails if we are piping to it */
+        BIO_flush(out);
         ERR_load_crypto_strings();
-        ERR_print_errors(out);
+        ERR_print_errors_fp(stderr);
         exit(1);
         return(1);
         }
@@ -228,7 +253,7 @@ int test_add(BIO *bp)
         BN_init(&c);
 
         BN_rand(&a,512,0,0);
-        for (i=0; i<100; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_rand(&b,450+i,0,0);
                 a.neg=rand_neg();
@@ -255,7 +280,7 @@ int test_add(BIO *bp)
                 BN_add(&c,&c,&a);
                 if(!BN_is_zero(&c))
                     {
-                    BIO_puts(bp,"Add test failed!\n");
+                    fprintf(stderr,"Add test failed!\n");
                     return 0;
                     }
                 }
@@ -275,12 +300,21 @@ int test_sub(BIO *bp)
         BN_init(&b);
         BN_init(&c);
 
-        BN_rand(&a,512,0,0);
-        for (i=0; i<100; i++)
+        for (i=0; i<num0+num1; i++)
                 {
-                BN_rand(&b,400+i,0,0);
-                a.neg=rand_neg();
-                b.neg=rand_neg();
+                if (i < num1)
+                        {
+                        BN_rand(&a,512,0,0);
+                        BN_copy(&b,&a);
+                        if (BN_set_bit(&a,i)==0) return(0);
+                        BN_add_word(&b,i);
+                        }
+                else
+                        {
+                        BN_rand(&b,400+i-num1,0,0);
+                        a.neg=rand_neg();
+                        b.neg=rand_neg();
+                        }
                 if (bp == NULL)
                         for (j=0; j<10000; j++)
                                 BN_sub(&c,&a,&b);
@@ -301,7 +335,7 @@ int test_sub(BIO *bp)
                 BN_sub(&c,&c,&a);
                 if(!BN_is_zero(&c))
                     {
-                    BIO_puts(bp,"Subtract test failed!\n");
+                    fprintf(stderr,"Subtract test failed!\n");
                     return 0;
                     }
                 }
@@ -323,10 +357,17 @@ int test_div(BIO *bp, BN_CTX *ctx)
         BN_init(&d);
         BN_init(&e);
 
-        BN_rand(&a,400,0,0);
-        for (i=0; i<100; i++)
+        for (i=0; i<num0+num1; i++)
                 {
-                BN_rand(&b,50+i,0,0);
+                if (i < num1)
+                        {
+                        BN_rand(&a,400,0,0);
+                        BN_copy(&b,&a);
+                        BN_lshift(&a,&a,i);
+                        BN_add_word(&a,i);
+                        }
+                else
+                        BN_rand(&b,50+3*(i-num1),0,0);
                 a.neg=rand_neg();
                 b.neg=rand_neg();
                 if (bp == NULL)
@@ -360,7 +401,7 @@ int test_div(BIO *bp, BN_CTX *ctx)
                 BN_sub(&d,&d,&a);
                 if(!BN_is_zero(&d))
                     {
-                    BIO_puts(bp,"Division test failed!\n");
+                    fprintf(stderr,"Division test failed!\n");
                     return 0;
                     }
                 }
@@ -386,10 +427,17 @@ int test_div_recp(BIO *bp, BN_CTX *ctx)
         BN_init(&d);
         BN_init(&e);
 
-        BN_rand(&a,400,0,0);
-        for (i=0; i<100; i++)
+        for (i=0; i<num0+num1; i++)
                 {
-                BN_rand(&b,50+i,0,0);
+                if (i < num1)
+                        {
+                        BN_rand(&a,400,0,0);
+                        BN_copy(&b,&a);
+                        BN_lshift(&a,&a,i);
+                        BN_add_word(&a,i);
+                        }
+                else
+                        BN_rand(&b,50+3*(i-num1),0,0);
                 a.neg=rand_neg();
                 b.neg=rand_neg();
                 BN_RECP_CTX_set(&recp,&b,ctx);
@@ -424,7 +472,12 @@ int test_div_recp(BIO *bp, BN_CTX *ctx)
                 BN_sub(&d,&d,&a);
                 if(!BN_is_zero(&d))
                     {
-                    BIO_puts(bp,"Reciprocal division test failed!\n");
+                    fprintf(stderr,"Reciprocal division test failed!\n");
+                    fprintf(stderr,"a=");
+                    BN_print_fp(stderr,&a);
+                    fprintf(stderr,"\nb=");
+                    BN_print_fp(stderr,&b);
+                    fprintf(stderr,"\n");
                     return 0;
                     }
                 }
@@ -451,11 +504,15 @@ int test_mul(BIO *bp)
         BN_init(&d);
         BN_init(&e);
 
-        BN_rand(&a,200,0,0);
-        for (i=0; i<100; i++)
+        for (i=0; i<num0+num1; i++)
                 {
-                BN_rand(&b,250+i,0,0);
-                BN_rand(&b,200,0,0);
+                if (i <= num1)
+                        {
+                        BN_rand(&a,100,0,0);
+                        BN_rand(&b,100,0,0);
+                        }
+                else
+                        BN_rand(&b,i-num1,0,0);
                 a.neg=rand_neg();
                 b.neg=rand_neg();
                 if (bp == NULL)
@@ -478,7 +535,7 @@ int test_mul(BIO *bp)
                 BN_sub(&d,&d,&b);
                 if(!BN_is_zero(&d) || !BN_is_zero(&e))
                     {
-                    BIO_puts(bp,"Multiplication test failed!\n");
+                    fprintf(stderr,"Multiplication test failed!\n");
                     return 0;
                     }
                 }
@@ -502,7 +559,7 @@ int test_sqr(BIO *bp, BN_CTX *ctx)
         BN_init(&d);
         BN_init(&e);
 
-        for (i=0; i<40; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_rand(&a,40+i*10,0,0);
                 a.neg=rand_neg();
@@ -526,7 +583,7 @@ int test_sqr(BIO *bp, BN_CTX *ctx)
                 BN_sub(&d,&d,&a);
                 if(!BN_is_zero(&d) || !BN_is_zero(&e))
                     {
-                    BIO_puts(bp,"Square test failed!\n");
+                    fprintf(stderr,"Square test failed!\n");
                     return 0;
                     }
                 }
@@ -557,9 +614,13 @@ int test_mont(BIO *bp, BN_CTX *ctx)
 
         BN_rand(&a,100,0,0); /**/
         BN_rand(&b,100,0,0); /**/
-        for (i=0; i<10; i++)
+        for (i=0; i<num2; i++)
                 {
-                BN_rand(&n,(100%BN_BITS2+1)*BN_BITS2*i*BN_BITS2,0,1); /**/
+                int bits = (200*(i+1))/num2;
+
+                if (bits == 0)
+                        continue;
+                BN_rand(&n,bits,0,1);
                 BN_MONT_CTX_set(mont,&n,ctx);
 
                 BN_to_montgomery(&A,&a,mont,ctx);
@@ -594,7 +655,7 @@ BN_num_bits(mont->N));
                 BN_sub(&d,&d,&A);
                 if(!BN_is_zero(&d))
                     {
-                    BIO_puts(bp,"Montgomery multiplication test failed!\n");
+                    fprintf(stderr,"Montgomery multiplication test failed!\n");
                     return 0;
                     }
                 }
@@ -622,7 +683,7 @@ int test_mod(BIO *bp, BN_CTX *ctx)
         e=BN_new();
 
         BN_rand(a,1024,0,0); /**/
-        for (i=0; i<20; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_rand(b,450+i*10,0,0); /**/
                 a->neg=rand_neg();
@@ -647,7 +708,7 @@ int test_mod(BIO *bp, BN_CTX *ctx)
                 BN_sub(e,e,c);
                 if(!BN_is_zero(e))
                     {
-                    BIO_puts(bp,"Modulo test failed!\n");
+                    fprintf(stderr,"Modulo test failed!\n");
                     return 0;
                     }
                 }
@@ -671,10 +732,10 @@ int test_mod_mul(BIO *bp, BN_CTX *ctx)
         e=BN_new();
 
         BN_rand(c,1024,0,0); /**/
-        for (i=0; i<10; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_rand(a,475+i*10,0,0); /**/
-                BN_rand(b,425+i*10,0,0); /**/
+                BN_rand(b,425+i*11,0,0); /**/
                 a->neg=rand_neg();
                 b->neg=rand_neg();
         /*      if (bp == NULL)
@@ -709,7 +770,7 @@ int test_mod_mul(BIO *bp, BN_CTX *ctx)
                 BN_div(a,b,d,c,ctx);
                 if(!BN_is_zero(b))
                     {
-                    BIO_puts(bp,"Modulo multiply test failed!\n");
+                    fprintf(stderr,"Modulo multiply test failed!\n");
                     return 0;
                     }
                 }
@@ -733,7 +794,7 @@ int test_mod_exp(BIO *bp, BN_CTX *ctx)
         e=BN_new();
 
         BN_rand(c,30,0,1); /* must be odd for montgomery */
-        for (i=0; i<6; i++)
+        for (i=0; i<num2; i++)
                 {
                 BN_rand(a,20+i*5,0,0); /**/
                 BN_rand(b,2+i,0,0); /**/
@@ -760,7 +821,7 @@ int test_mod_exp(BIO *bp, BN_CTX *ctx)
                 BN_div(a,b,e,c,ctx);
                 if(!BN_is_zero(b))
                     {
-                    BIO_puts(bp,"Modulo exponentiation test failed!\n");
+                    fprintf(stderr,"Modulo exponentiation test failed!\n");
                     return 0;
                     }
                 }
@@ -784,7 +845,7 @@ int test_exp(BIO *bp, BN_CTX *ctx)
         one=BN_new();
         BN_one(one);
 
-        for (i=0; i<6; i++)
+        for (i=0; i<num2; i++)
                 {
                 BN_rand(a,20+i*5,0,0); /**/
                 BN_rand(b,2+i,0,0); /**/
@@ -810,7 +871,7 @@ int test_exp(BIO *bp, BN_CTX *ctx)
                 BN_sub(e,e,d);
                 if(!BN_is_zero(e))
                     {
-                    BIO_puts(bp,"Exponentiation test failed!\n");
+                    fprintf(stderr,"Exponentiation test failed!\n");
                     return 0;
                     }
                 }
@@ -840,7 +901,7 @@ int test_lshift(BIO *bp,BN_CTX *ctx,BIGNUM *a_)
             BN_rand(a,200,0,0); /**/
             a->neg=rand_neg();
             }
-        for (i=0; i<70; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_lshift(b,a,i+1);
                 BN_add(c,c,c);
@@ -860,16 +921,16 @@ int test_lshift(BIO *bp,BN_CTX *ctx,BIGNUM *a_)
                 BN_sub(d,d,b);
                 if(!BN_is_zero(d))
                     {
-                    BIO_puts(bp,"Left shift test failed!\n");
-                    BIO_puts(bp,"a=");
-                    BN_print(bp,a);
-                    BIO_puts(bp,"\nb=");
-                    BN_print(bp,b);
-                    BIO_puts(bp,"\nc=");
-                    BN_print(bp,c);
-                    BIO_puts(bp,"\nd=");
-                    BN_print(bp,d);
-                    BIO_puts(bp,"\n");
+                    fprintf(stderr,"Left shift test failed!\n");
+                    fprintf(stderr,"a=");
+                    BN_print_fp(stderr,a);
+                    fprintf(stderr,"\nb=");
+                    BN_print_fp(stderr,b);
+                    fprintf(stderr,"\nc=");
+                    BN_print_fp(stderr,c);
+                    fprintf(stderr,"\nd=");
+                    BN_print_fp(stderr,d);
+                    fprintf(stderr,"\n");
                     return 0;
                     }
                 }
@@ -891,7 +952,7 @@ int test_lshift1(BIO *bp)
 
         BN_rand(a,200,0,0); /**/
         a->neg=rand_neg();
-        for (i=0; i<70; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_lshift1(b,a);
                 if (bp != NULL)
@@ -909,7 +970,7 @@ int test_lshift1(BIO *bp)
                 BN_sub(a,b,c);
                 if(!BN_is_zero(a))
                     {
-                    BIO_puts(bp,"Left shift one test failed!\n");
+                    fprintf(stderr,"Left shift one test failed!\n");
                     return 0;
                     }
                 
@@ -935,7 +996,7 @@ int test_rshift(BIO *bp,BN_CTX *ctx)
 
         BN_rand(a,200,0,0); /**/
         a->neg=rand_neg();
-        for (i=0; i<70; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_rshift(b,a,i+1);
                 BN_add(c,c,c);
@@ -955,7 +1016,7 @@ int test_rshift(BIO *bp,BN_CTX *ctx)
                 BN_sub(d,d,b);
                 if(!BN_is_zero(d))
                     {
-                    BIO_puts(bp,"Right shift test failed!\n");
+                    fprintf(stderr,"Right shift test failed!\n");
                     return 0;
                     }
                 }
@@ -978,7 +1039,7 @@ int test_rshift1(BIO *bp)
 
         BN_rand(a,200,0,0); /**/
         a->neg=rand_neg();
-        for (i=0; i<70; i++)
+        for (i=0; i<num0; i++)
                 {
                 BN_rshift1(b,a);
                 if (bp != NULL)
@@ -996,7 +1057,7 @@ int test_rshift1(BIO *bp)
                 BN_sub(c,c,b);
                 if(!BN_is_zero(c) && !BN_is_one(c))
                     {
-                    BIO_puts(bp,"Right shift one test failed!\n");
+                    fprintf(stderr,"Right shift one test failed!\n");
                     return 0;
                     }
                 BN_copy(a,b);
diff --git a/src/lib/libcrypto/bn/comba.pl b/src/lib/libcrypto/bn/comba.pl
index 211a8b45c7..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/comba.pl
+++ b/src/lib/libcrypto/bn/comba.pl
@@ -1,285 +0,0 @@
-#!/usr/local/bin/perl
-
-$num=8;
-$num2=8/2;
-
-print <<"EOF";
-/* crypto/bn/bn_comba.c */
-#include <stdio.h>
-#include "bn_lcl.h"
-/* Auto generated from crypto/bn/comba.pl
- */
-
-#undef bn_mul_comba8
-#undef bn_mul_comba4
-#undef bn_sqr_comba8
-#undef bn_sqr_comba4
-
-#ifdef BN_LLONG
-#define mul_add_c(a,b,c0,c1,c2) \\
-        t=(BN_ULLONG)a*b; \\
-        t1=(BN_ULONG)Lw(t); \\
-        t2=(BN_ULONG)Hw(t); \\
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \\
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define mul_add_c2(a,b,c0,c1,c2) \\
-        t=(BN_ULLONG)a*b; \\
-        tt=(t+t)&BN_MASK; \\
-        if (tt < t) c2++; \\
-        t1=(BN_ULONG)Lw(tt); \\
-        t2=(BN_ULONG)Hw(tt); \\
-        c0=(c0+t1)&BN_MASK2;  \\
-        if ((c0 < t1) && (((++t2)&BN_MASK2) == 0)) c2++; \\
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c(a,i,c0,c1,c2) \\
-        t=(BN_ULLONG)a[i]*a[i]; \\
-        t1=(BN_ULONG)Lw(t); \\
-        t2=(BN_ULONG)Hw(t); \\
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \\
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c2(a,i,j,c0,c1,c2) \\
-        mul_add_c2((a)[i],(a)[j],c0,c1,c2)
-#else
-#define mul_add_c(a,b,c0,c1,c2) \\
-        t1=LBITS(a); t2=HBITS(a); \\
-        bl=LBITS(b); bh=HBITS(b); \\
-        mul64(t1,t2,bl,bh); \\
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \\
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define mul_add_c2(a,b,c0,c1,c2) \\
-        t1=LBITS(a); t2=HBITS(a); \\
-        bl=LBITS(b); bh=HBITS(b); \\
-        mul64(t1,t2,bl,bh); \\
-        if (t2 & BN_TBIT) c2++; \\
-        t2=(t2+t2)&BN_MASK2; \\
-        if (t1 & BN_TBIT) t2++; \\
-        t1=(t1+t1)&BN_MASK2; \\
-        c0=(c0+t1)&BN_MASK2;  \\
-        if ((c0 < t1) && (((++t2)&BN_MASK2) == 0)) c2++; \\
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c(a,i,c0,c1,c2) \\
-        sqr64(t1,t2,(a)[i]); \\
-        c0=(c0+t1)&BN_MASK2; if ((c0) < t1) t2++; \\
-        c1=(c1+t2)&BN_MASK2; if ((c1) < t2) c2++;
-
-#define sqr_add_c2(a,i,j,c0,c1,c2) \\
-        mul_add_c2((a)[i],(a)[j],c0,c1,c2)
-#endif
-
-void bn_mul_comba${num}(r,a,b)
-BN_ULONG *r,*a,*b;
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-EOF
-$ret=&combas_mul("r","a","b",$num,"c1","c2","c3");
-printf <<"EOF";
-        }
-
-void bn_mul_comba${num2}(r,a,b)
-BN_ULONG *r,*a,*b;
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-EOF
-$ret=&combas_mul("r","a","b",$num2,"c1","c2","c3");
-printf <<"EOF";
-        }
-
-void bn_sqr_comba${num}(r,a)
-BN_ULONG *r,*a;
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t,tt;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-EOF
-$ret=&combas_sqr("r","a",$num,"c1","c2","c3");
-printf <<"EOF";
-        }
-
-void bn_sqr_comba${num2}(r,a)
-BN_ULONG *r,*a;
-        {
-#ifdef BN_LLONG
-        BN_ULLONG t,tt;
-#else
-        BN_ULONG bl,bh;
-#endif
-        BN_ULONG t1,t2;
-        BN_ULONG c1,c2,c3;
-
-EOF
-$ret=&combas_sqr("r","a",$num2,"c1","c2","c3");
-printf <<"EOF";
-        }
-EOF
-
-sub bn_str
-        {
-        local($var,$val)=@_;
-        print "\t$var=$val;\n";
-        }
-
-sub bn_ary
-        {
-        local($var,$idx)=@_;
-        return("${var}[$idx]");
-        }
-
-sub bn_clr
-        {
-        local($var)=@_;
-
-        print "\t$var=0;\n";
-        }
-
-sub bn_mad
-        {
-        local($a,$b,$c0,$c1,$c2,$num)=@_;
-
-        if ($num == 2)
-                { printf("\tmul_add_c2($a,$b,$c0,$c1,$c2);\n"); }
-        else
-                { printf("\tmul_add_c($a,$b,$c0,$c1,$c2);\n"); }
-        }
-
-sub bn_sad
-        {
-        local($a,$i,$j,$c0,$c1,$c2,$num)=@_;
-
-        if ($num == 2)
-                { printf("\tsqr_add_c2($a,$i,$j,$c0,$c1,$c2);\n"); }
-        else
-                { printf("\tsqr_add_c($a,$i,$c0,$c1,$c2);\n"); }
-        }
-
-sub combas_mul
-        {
-        local($r,$a,$b,$num,$c0,$c1,$c2)=@_;
-        local($i,$as,$ae,$bs,$be,$ai,$bi);
-        local($tot,$end);
-
-        $as=0;
-        $ae=0;
-        $bs=0;
-        $be=0;
-        $tot=$num+$num-1;
-        &bn_clr($c0);
-        &bn_clr($c1);
-        for ($i=0; $i<$tot; $i++)
-                {
-                $ai=$as;
-                $bi=$bs;
-                $end=$be+1;
-                @numa=@numb=();
-
-#print "($as $ae) ($bs $be) $bs -> $end [$i $num]\n";
-                for ($j=$bs; $j<$end; $j++)
-                        {
-                        push(@numa,$ai);
-                        push(@numb,$bi);
-                        $ai--;
-                        $bi++;
-                        }
-
-                if ($i & 1)
-                        {
-                        @numa=reverse(@numa);
-                        @numb=reverse(@numb);
-                        }
-
-                &bn_clr($c2);
-                for ($j=0; $j<=$#numa; $j++)
-                        {
-                        &bn_mad(&bn_ary($a,$numa[$j]),
-                                &bn_ary($b,$numb[$j]),$c0,$c1,$c2,1);
-                        }
-                &bn_str(&bn_ary($r,$i),$c0);
-                ($c0,$c1,$c2)=($c1,$c2,$c0);
-
-                $as++ if ($i < ($num-1));
-                $ae++ if ($i >= ($num-1));
-
-                $bs++ if ($i >= ($num-1));
-                $be++ if ($i < ($num-1));
-                }
-        &bn_str(&bn_ary($r,$i),$c0);
-        }
-
-sub combas_sqr
-        {
-        local($r,$a,$num,$c0,$c1,$c2)=@_;
-        local($i,$as,$ae,$bs,$be,$ai,$bi);
-        local($b,$tot,$end,$half);
-
-        $b=$a;
-        $as=0;
-        $ae=0;
-        $bs=0;
-        $be=0;
-        $tot=$num+$num-1;
-        &bn_clr($c0);
-        &bn_clr($c1);
-        for ($i=0; $i<$tot; $i++)
-                {
-                $ai=$as;
-                $bi=$bs;
-                $end=$be+1;
-                @numa=@numb=();
-
-#print "($as $ae) ($bs $be) $bs -> $end [$i $num]\n";
-                for ($j=$bs; $j<$end; $j++)
-                        {
-                        push(@numa,$ai);
-                        push(@numb,$bi);
-                        $ai--;
-                        $bi++;
-                        last if ($ai < $bi);
-                        }
-                if (!($i & 1))
-                        {
-                        @numa=reverse(@numa);
-                        @numb=reverse(@numb);
-                        }
-
-                &bn_clr($c2);
-                for ($j=0; $j <= $#numa; $j++)
-                        {
-                        if ($numa[$j] == $numb[$j])
-                                {&bn_sad($a,$numa[$j],$numb[$j],$c0,$c1,$c2,1);}
-                        else
-                                {&bn_sad($a,$numa[$j],$numb[$j],$c0,$c1,$c2,2);}
-                        }
-                &bn_str(&bn_ary($r,$i),$c0);
-                ($c0,$c1,$c2)=($c1,$c2,$c0);
-
-                $as++ if ($i < ($num-1));
-                $ae++ if ($i >= ($num-1));
-
-                $bs++ if ($i >= ($num-1));
-                $be++ if ($i < ($num-1));
-                }
-        &bn_str(&bn_ary($r,$i),$c0);
-        }
diff --git a/src/lib/libcrypto/bn/d.c b/src/lib/libcrypto/bn/d.c
index ced2291b25..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/d.c
+++ b/src/lib/libcrypto/bn/d.c
@@ -1,72 +0,0 @@
-#include <stdio.h>
-#include <openssl/bio.h>
-#include "bn_lcl.h"
-
-#define SIZE_A (100*4+4)
-#define SIZE_B (13*4)
-
-main(argc,argv)
-int argc;
-char *argv[];
-        {
-        BN_CTX ctx;
-        BN_RECP_CTX recp;
-        BIGNUM a,b,dd,d,r,rr,t,l;
-        int i;
-
-        MemCheck_start();
-        MemCheck_on();
-        BN_CTX_init(&ctx);
-        BN_RECP_CTX_init(&recp);
-
-        BN_init(&r);
-        BN_init(&rr);
-        BN_init(&d);
-        BN_init(&dd);
-        BN_init(&a);
-        BN_init(&b);
-
-        {
-        BN_rand(&a,SIZE_A,0,0);
-        BN_rand(&b,SIZE_B,0,0);
-
-        a.neg=1;
-        BN_RECP_CTX_set(&recp,&b,&ctx);
-
-        BN_print_fp(stdout,&a); printf(" a\n");
-        BN_print_fp(stdout,&b); printf(" b\n");
-
-        BN_print_fp(stdout,&recp.N); printf(" N\n");
-        BN_print_fp(stdout,&recp.Nr); printf(" Nr num_bits=%d\n",recp.num_bits);
-
-        BN_div_recp(&r,&d,&a,&recp,&ctx);
-
-for (i=0; i<300; i++)
-        BN_div(&rr,&dd,&a,&b,&ctx);
-
-        BN_print_fp(stdout,&r); printf(" div recp\n");
-        BN_print_fp(stdout,&rr); printf(" div\n");
-        BN_print_fp(stdout,&d); printf(" rem recp\n");
-        BN_print_fp(stdout,&dd); printf(" rem\n");
-        }
-        BN_CTX_free(&ctx);
-        BN_RECP_CTX_free(&recp);
-
-        BN_free(&r);
-        BN_free(&rr);
-        BN_free(&d);
-        BN_free(&dd);
-        BN_free(&a);
-        BN_free(&b);
-
-        {
-        BIO *out;
-
-        if ((out=BIO_new(BIO_s_file())) != NULL)
-                BIO_set_fp(out,stderr,BIO_NOCLOSE|BIO_FP_TEXT);
-
-        CRYPTO_mem_leaks(out);
-        BIO_free(out);
-        }
-
-        }
diff --git a/src/lib/libcrypto/bn/divtest.c b/src/lib/libcrypto/bn/divtest.c
new file mode 100644
index 0000000000..13ba86e3c4
--- /dev/null
+++ b/src/lib/libcrypto/bn/divtest.c
@@ -0,0 +1,41 @@
+#include <openssl/bn.h>
+#include <openssl/rand.h>
+
+static int rand(n)
+{
+    unsigned char x[2];
+    RAND_pseudo_bytes(x,2);
+    return (x[0] + 2*x[1]);
+}
+
+static void bug(char *m, BIGNUM *a, BIGNUM *b)
+{
+    printf("%s!\na=",m);
+    BN_print_fp(stdout, a);
+    printf("\nb=");
+    BN_print_fp(stdout, b);
+    printf("\n");
+    fflush(stdout);
+}
+
+main()
+{
+    BIGNUM *a=BN_new(), *b=BN_new(), *c=BN_new(), *d=BN_new(),
+        *C=BN_new(), *D=BN_new();
+    BN_RECP_CTX *recp=BN_RECP_CTX_new();
+    BN_CTX *ctx=BN_CTX_new();
+
+    for(;;) {
+        BN_pseudo_rand(a,rand(),0,0);
+        BN_pseudo_rand(b,rand(),0,0);
+        if (BN_is_zero(b)) continue;
+
+        BN_RECP_CTX_set(recp,b,ctx);
+        if (BN_div(C,D,a,b,ctx) != 1)
+            bug("BN_div failed",a,b);
+        if (BN_div_recp(c,d,a,recp,ctx) != 1)
+            bug("BN_div_recp failed",a,b);
+        else if (BN_cmp(c,C) != 0 || BN_cmp(c,C) != 0)
+            bug("mismatch",a,b);
+    }
+}
diff --git a/src/lib/libcrypto/bn/exp.c b/src/lib/libcrypto/bn/exp.c
index ec443459d8..4865b0ef74 100644
--- a/src/lib/libcrypto/bn/exp.c
+++ b/src/lib/libcrypto/bn/exp.c
@@ -1,3 +1,5 @@
+/* unused */
+
 #include <stdio.h>
 #include <openssl/tmdiff.h>
 #include "bn_lcl.h"
diff --git a/src/lib/libcrypto/bn/expspeed.c b/src/lib/libcrypto/bn/expspeed.c
index 3656d5bb4c..2044ab9bff 100644
--- a/src/lib/libcrypto/bn/expspeed.c
+++ b/src/lib/libcrypto/bn/expspeed.c
@@ -1,3 +1,5 @@
+/* unused */
+
 /* crypto/bn/expspeed.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
diff --git a/src/lib/libcrypto/bn/exptest.c b/src/lib/libcrypto/bn/exptest.c
index 9e4ae91d20..3e86f2ea0e 100644
--- a/src/lib/libcrypto/bn/exptest.c
+++ b/src/lib/libcrypto/bn/exptest.c
@@ -69,6 +69,8 @@
 
 #define NUM_BITS        (BN_BITS*2)
 
+static const char rnd_seed[] = "string to make the random number generator think it has entropy";
+
 int main(int argc, char *argv[])
         {
         BN_CTX *ctx;
@@ -77,6 +79,10 @@ int main(int argc, char *argv[])
         unsigned char c;
         BIGNUM *r_mont,*r_recp,*r_simple,*a,*b,*m;
 
+        RAND_seed(rnd_seed, sizeof rnd_seed); /* or BN_rand may fail, and we don't
+                                               * even check its return value
+                                               * (which we should) */
+
         ERR_load_BN_strings();
 
         ctx=BN_CTX_new();
@@ -160,7 +166,16 @@ int main(int argc, char *argv[])
                         exit(1);
                         }
                 }
+        BN_free(r_mont);
+        BN_free(r_recp);
+        BN_free(r_simple);
+        BN_free(a);
+        BN_free(b);
+        BN_free(m);
+        BN_CTX_free(ctx);
+        ERR_remove_state(0);
         CRYPTO_mem_leaks(out);
+        BIO_free(out);
         printf(" done\n");
         exit(0);
 err:
diff --git a/src/lib/libcrypto/bn/new b/src/lib/libcrypto/bn/new
index 285d506f19..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/new
+++ b/src/lib/libcrypto/bn/new
@@ -1,23 +0,0 @@
-void BN_RECP_CTX_init(BN_RECP_CTX *recp);
-BN_RECP_CTX *BN_RECP_CTX_new();
-void BN_RECP_CTX_free(BN_RECP_CTX *recp);
-int BN_RECP_CTX_set(BN_RECP_CTX *recp,BIGNUM *div,BN_CTX *ctx);
-
-int BN_mod_exp_recp(BIGNUM *r, BIGNUM *a, BIGNUM *p, BIGNUM *m,
-        BN_RECP_CTX *recp,BN_CTX *ctx);
-
-int BN_div_recp(BIGNUM *dv, BIGNUM *rem, BIGNUM *m, BIGNUM *d,
-        BN_RECP_CTX *recp, BN_CTX *ctx);
-int BN_mod_recp(BIGNUM *rem, BIGNUM *m, BIGNUM *d,
-        BN_RECP_CTX *recp, BN_CTX *ctx);
-int BN_mod_mul_recp(BIGNUM *ret,BIGNUM *a,BIGNUM *b,BIGNUM *m
-
-int BN_mod_exp_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *p,
-        BN_MONT_CTX *m_ctx,BN_CTX *ctx);
-int BN_mod_exp2_montgomery(BIGNUM *r, BIGNUM *a1, BIGNUM *p1,BIGNUM *a2,
-                BIGNUM *p2,BN_MONT_CTX *m_ctx,BN_CTX *ctx);
-
-
-bn_div64 -> bn_div_words
-
-
diff --git a/src/lib/libcrypto/bn/old/b_sqr.c b/src/lib/libcrypto/bn/old/b_sqr.c
index 715cb1c8ab..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/b_sqr.c
+++ b/src/lib/libcrypto/bn/old/b_sqr.c
@@ -1,199 +0,0 @@
-/* crypto/bn/bn_mul.c */
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-#include <stdio.h>
-#include "cryptlib.h"
-#include "bn_lcl.h"
-
-static int bn_mm(BIGNUM *m,BIGNUM *A,BIGNUM *B, BIGNUM *sk,BN_CTX *ctx);
-
-/* r must be different to a and b */
-/* int BN_mmul(r, a, b) */
-int BN_mul(BIGNUM *r, BIGNUM *a, BIGNUM *b)
-        {
-        BN_ULONG *ap,*bp,*rp;
-        BIGNUM *sk;
-        int i,n,ret;
-        int max,al,bl;
-        BN_CTX ctx;
-
-        bn_check_top(a);
-        bn_check_top(b);
-
-        al=a->top;
-        bl=b->top;
-        if ((al == 0) || (bl == 0))
-                {
-                r->top=0;
-                return(1);
-                }
-#ifdef BN_MUL_DEBUG
-printf("BN_mul(%d,%d)\n",a->top,b->top);
-#endif
-
-        if (    (bn_limit_bits > 0) &&
-                (bl > bn_limit_num) && (al > bn_limit_num))
-                {
-                n=(BN_num_bits_word(al|bl)-bn_limit_bits);
-                n*=2;
-                sk=(BIGNUM *)Malloc(sizeof(BIGNUM)*n);
-                memset(sk,0,sizeof(BIGNUM)*n);
-                memset(&ctx,0,sizeof(ctx));
-
-                ret=bn_mm(r,a,b,&(sk[0]),&ctx);
-                for (i=0; i<n; i+=2)
-                        {
-                        BN_clear_free(&sk[i]);
-                        BN_clear_free(&sk[i+1]);
-                        }
-                Free(sk);
-                return(ret);
-                }
-
-        max=(al+bl);
-        if (bn_wexpand(r,max) == NULL) return(0);
-        r->top=max;
-        r->neg=a->neg^b->neg;
-        ap=a->d;
-        bp=b->d;
-        rp=r->d;
-
-        rp[al]=bn_mul_words(rp,ap,al,*(bp++));
-        rp++;
-        for (i=1; i<bl; i++)
-                {
-                rp[al]=bn_mul_add_words(rp,ap,al,*(bp++));
-                rp++;
-                }
-        if ((max > 0) && (r->d[max-1] == 0)) r->top--;
-        return(1);
-        }
-
-
-#define ahal    (sk[0])
-#define blbh    (sk[1])
-
-/* r must be different to a and b */
-int bn_mm(BIGNUM *m, BIGNUM *A, BIGNUM *B, BIGNUM *sk, BN_CTX *ctx)
-        {
-        int n,num,sqr=0;
-        int an,bn;
-        BIGNUM ah,al,bh,bl;
-
-        an=A->top;
-        bn=B->top;
-#ifdef BN_MUL_DEBUG
-printf("bn_mm(%d,%d)\n",A->top,B->top);
-#endif
-
-        if (A == B) sqr=1;
-        num=(an>bn)?an:bn;
-        n=(num+1)/2;
-        /* Are going to now chop things into 'num' word chunks. */
-
-        BN_init(&ah);
-        BN_init(&al);
-        BN_init(&bh);
-        BN_init(&bl);
-
-        bn_set_low (&al,A,n);
-        bn_set_high(&ah,A,n);
-        bn_set_low (&bl,B,n);
-        bn_set_high(&bh,B,n);
-
-        BN_sub(&ahal,&ah,&al);
-        BN_sub(&blbh,&bl,&bh);
-
-        if (num <= (bn_limit_num+bn_limit_num))
-                {
-                BN_mul(m,&ahal,&blbh);
-                if (sqr)
-                        {
-                        BN_sqr(&ahal,&al,ctx);
-                        BN_sqr(&blbh,&ah,ctx);
-                        }
-                else
-                        {
-                        BN_mul(&ahal,&al,&bl);
-                        BN_mul(&blbh,&ah,&bh);
-                        }
-                }
-        else
-                {
-                bn_mm(m,&ahal,&blbh,&(sk[2]),ctx);
-                bn_mm(&ahal,&al,&bl,&(sk[2]),ctx);
-                bn_mm(&blbh,&ah,&bh,&(sk[2]),ctx);
-                }
-
-        BN_add(m,m,&ahal);
-        BN_add(m,m,&blbh);
-
-        BN_lshift(m,m,n*BN_BITS2);
-        BN_lshift(&blbh,&blbh,n*BN_BITS2*2);
-
-        BN_add(m,m,&ahal);
-        BN_add(m,m,&blbh);
-
-        m->neg=A->neg^B->neg;
-        return(1);
-        }
-#undef ahal     (sk[0])
-#undef blbh     (sk[1])
-
-#include "bn_low.c"
-#include "bn_high.c"
diff --git a/src/lib/libcrypto/bn/old/bn_com.c b/src/lib/libcrypto/bn/old/bn_com.c
index 7666b2304c..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/bn_com.c
+++ b/src/lib/libcrypto/bn/old/bn_com.c
@@ -1,90 +0,0 @@
-/* crypto/bn/bn_mulw.c */
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-#include <stdio.h>
-#include "cryptlib.h"
-#include "bn_lcl.h"
-
-#ifdef BN_LLONG 
-
-ab
-12
-   a2 b2
-a1 b1
-
-abc
-123
-      a3 b3 c3
-   a2 b2 c2
-a1 b1 c1
-
-abcd
-1234
-         a4 b4 c4 d4
-      a3 b3 c3 d3
-   a2 b2 c2 d2
-a1 b1 c1 d1
-
-abcde
-01234
-               a5 b5 c5 d5 e5
-            a4 b4 c4 d4 e4
-         a3 b3 c3 d3 e3
-      a2 b2 c2 d2 e2
-   a1 b1 c1 d1 e1
-a0 b0 c0 d0 e0
diff --git a/src/lib/libcrypto/bn/old/bn_high.c b/src/lib/libcrypto/bn/old/bn_high.c
index 763bcb605b..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/bn_high.c
+++ b/src/lib/libcrypto/bn/old/bn_high.c
@@ -1,135 +0,0 @@
-#include <stdio.h>
-#include "cryptlib.h"
-#include "bn_lcl.h"
-
-#undef BN_MUL_HIGH_DEBUG
-
-#ifdef BN_MUL_HIGH_DEBUG
-#define debug_BN_print(a,b,c) BN_print_fp(a,b); printf(c);
-#else
-#define debug_BN_print(a,b,c)
-#endif
-
-int BN_mul_high(BIGNUM *r,BIGNUM *a,BIGNUM *b,BIGNUM *low, int words);
-
-#undef t1
-#undef t2
-
-int BN_mul_high(BIGNUM *r, BIGNUM *a, BIGNUM *b, BIGNUM *low, int words)
-        {
-        int w2,borrow=0,full=0;
-        BIGNUM t1,t2,t3,h,ah,al,bh,bl,m,s0,s1;
-        BN_ULONG ul1,ul2;
-        
-        BN_mul(r,a,b);
-        BN_rshift(r,r,words*BN_BITS2);
-        return(1);
-
-        w2=(words+1)/2;
-
-#ifdef BN_MUL_HIGH_DEBUG
-fprintf(stdout,"words=%d w2=%d\n",words,w2);
-#endif
-debug_BN_print(stdout,a," a\n");
-debug_BN_print(stdout,b," b\n");
-debug_BN_print(stdout,low," low\n");
-        BN_init(&al); BN_init(&ah);
-        BN_init(&bl); BN_init(&bh);
-        BN_init(&t1); BN_init(&t2); BN_init(&t3);
-        BN_init(&s0); BN_init(&s1);
-        BN_init(&h); BN_init(&m);
-
-        bn_set_low (&al,a,w2);
-        bn_set_high(&ah,a,w2);
-        bn_set_low (&bl,b,w2);
-        bn_set_high(&bh,b,w2);
-
-        bn_set_low(&s0,low,w2);
-        bn_set_high(&s1,low,w2);
-
-debug_BN_print(stdout,&al," al\n");
-debug_BN_print(stdout,&ah," ah\n");
-debug_BN_print(stdout,&bl," bl\n");
-debug_BN_print(stdout,&bh," bh\n");
-debug_BN_print(stdout,&s0," s0\n");
-debug_BN_print(stdout,&s1," s1\n");
-
-        /* Calculate (al-ah)*(bh-bl) */
-        BN_sub(&t1,&al,&ah);
-        BN_sub(&t2,&bh,&bl);
-        BN_mul(&m,&t1,&t2);
-
-        /* Calculate ah*bh */
-        BN_mul(&h,&ah,&bh);
-
-        /* s0 == low(al*bl)
-         * s1 == low(ah*bh)+low((al-ah)*(bh-bl))+low(al*bl)+high(al*bl)
-         * We know s0 and s1 so the only unknown is high(al*bl)
-         * high(al*bl) == s1 - low(ah*bh+(al-ah)*(bh-bl)+s0)
-         */
-        BN_add(&m,&m,&h);
-        BN_add(&t2,&m,&s0);
-
-debug_BN_print(stdout,&t2," middle value\n");
-
-        /* Quick and dirty mask off of high words */
-        if (w2 < t2.top) t2.top=w2;
-#if 0
-        bn_set_low(&t3,&t2,w2);
-#endif
-
-debug_BN_print(stdout,&t2," low middle value\n");
-        BN_sub(&t1,&s1,&t2);
-
-        if (t1.neg)
-                {
-debug_BN_print(stdout,&t1," before\n");
-                BN_zero(&t2);
-                BN_set_bit(&t2,w2*BN_BITS2);
-                BN_add(&t1,&t2,&t1);
-                /* BN_mask_bits(&t1,w2*BN_BITS2); */
-                /* if (words < t1.top) t1.top=words; */
-debug_BN_print(stdout,&t1," after\n");
-                borrow=1;
-                }
-
-/* XXXXX SPEED THIS UP */
-        /* al*bl == high(al*bl)<<words+s0 */
-        BN_lshift(&t1,&t1,w2*BN_BITS2);
-        BN_add(&t1,&t1,&s0);
-        if (w2*2 < t1.top) t1.top=w2*2; /* This should not happen? */
-        
-        /* We now have
-         * al*bl                        - t1
-         * (al-ah)*(bh-bl)+ah*bh        - m
-         * ah*bh                        - h
-         */
-#if 0
-        BN_add(&m,&m,&t1);
-debug_BN_print(stdout,&t1," s10\n");
-debug_BN_print(stdout,&m," s21\n");
-debug_BN_print(stdout,&h," s32\n");
-        BN_lshift(&m,&m,w2*BN_BITS2);
-        BN_lshift(&h,&h,w2*2*BN_BITS2);
-        BN_add(r,&m,&t1);
-        BN_add(r,r,&h);
-        BN_rshift(r,r,w2*2*BN_BITS2);
-#else
-        BN_add(&m,&m,&t1);              /* Do a cmp then +1 if needed? */
-        bn_set_high(&t3,&t1,w2);
-        BN_add(&m,&m,&t3);
-        bn_set_high(&t3,&m,w2);
-        BN_add(r,&h,&t3);
-#endif
-
-#ifdef BN_MUL_HIGH_DEBUG
-printf("carry=%d\n",borrow);
-#endif
-debug_BN_print(stdout,r," ret\n");
-        BN_free(&t1); BN_free(&t2);
-        BN_free(&m); BN_free(&h);
-        return(1);
-        }
-
-
-
diff --git a/src/lib/libcrypto/bn/old/bn_ka.c b/src/lib/libcrypto/bn/old/bn_ka.c
index 378c94dc5a..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/bn_ka.c
+++ b/src/lib/libcrypto/bn/old/bn_ka.c
@@ -1,567 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <strings.h>
-#include "bn_lcl.h"
-
-/* r is 2*n2 words in size,
- * a and b are both n2 words in size.
- * n2 must be a power of 2.
- * We multiply and return the result.
- * t must be 2*n2 words in size
- * We calulate
- * a[0]*b[0]
- * a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
- * a[1]*b[1]
- */
-void bn_mul_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
-             BN_ULONG *t)
-        {
-        int n=n2/2;
-        int neg,zero,c1,c2;
-        BN_ULONG ln,lo,*p;
-
-#ifdef BN_COUNT
-printf(" bn_mul_recursive %d * %d\n",n2,n2);
-#endif
-        if (n2 <= 8)
-                {
-                if (n2 == 8)
-                        bn_mul_comba8(r,a,b);
-                else
-                        bn_mul_normal(r,a,n2,b,n2);
-                return;
-                }
-
-        if (n2 < BN_MUL_RECURSIVE_SIZE_NORMAL)
-                {
-                /* This should not happen */
-                /*abort(); */
-                bn_mul_normal(r,a,n2,b,n2);
-                return;
-                }
-        /* r=(a[0]-a[1])*(b[1]-b[0]) */
-        c1=bn_cmp_words(a,&(a[n]),n);
-        c2=bn_cmp_words(&(b[n]),b,n);
-        zero=neg=0;
-        switch (c1*3+c2)
-                {
-        case -4:
-                bn_sub_words(t,      &(a[n]),a,      n); /* - */
-                bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
-                break;
-        case -3:
-                zero=1;
-                break;
-        case -2:
-                bn_sub_words(t,      &(a[n]),a,      n); /* - */
-                bn_sub_words(&(t[n]),&(b[n]),b,      n); /* + */
-                neg=1;
-                break;
-        case -1:
-        case 0:
-        case 1:
-                zero=1;
-                break;
-        case 2:
-                bn_sub_words(t,      a,      &(a[n]),n); /* + */
-                bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
-                neg=1;
-                break;
-        case 3:
-                zero=1;
-                break;
-        case 4:
-                bn_sub_words(t,      a,      &(a[n]),n);
-                bn_sub_words(&(t[n]),&(b[n]),b,      n);
-                break;
-                }
-
-        if (n == 8)
-                {
-                if (!zero)
-                        bn_mul_comba8(&(t[n2]),t,&(t[n]));
-                else
-                        memset(&(t[n2]),0,8*sizeof(BN_ULONG));
-                
-                bn_mul_comba8(r,a,b);
-                bn_mul_comba8(&(r[n2]),&(a[n]),&(b[n]));
-                }
-        else
-                {
-                p= &(t[n2*2]);
-                if (!zero)
-                        bn_mul_recursive(&(t[n2]),t,&(t[n]),n,p);
-                else
-                        memset(&(t[n2]),0,n*sizeof(BN_ULONG));
-                bn_mul_recursive(r,a,b,n,p);
-                bn_mul_recursive(&(r[n2]),&(a[n]),&(b[n]),n,p);
-                }
-
-        /* t[32] holds (a[0]-a[1])*(b[1]-b[0]), c1 is the sign
-         * r[10] holds (a[0]*b[0])
-         * r[32] holds (b[1]*b[1])
-         */
-
-        c1=bn_add_words(t,r,&(r[n2]),n2);
-
-        if (neg) /* if t[32] is negative */
-                {
-                c1-=bn_sub_words(&(t[n2]),t,&(t[n2]),n2);
-                }
-        else
-                {
-                /* Might have a carry */
-                c1+=bn_add_words(&(t[n2]),&(t[n2]),t,n2);
-                }
-
-        /* t[32] holds (a[0]-a[1])*(b[1]-b[0])+(a[0]*b[0])+(a[1]*b[1])
-         * r[10] holds (a[0]*b[0])
-         * r[32] holds (b[1]*b[1])
-         * c1 holds the carry bits
-         */
-        c1+=bn_add_words(&(r[n]),&(r[n]),&(t[n2]),n2);
-        if (c1)
-                {
-                p= &(r[n+n2]);
-                lo= *p;
-                ln=(lo+c1)&BN_MASK2;
-                *p=ln;
-
-                /* The overflow will stop before we over write
-                 * words we should not overwrite */
-                if (ln < c1)
-                        {
-                        do      {
-                                p++;
-                                lo= *p;
-                                ln=(lo+1)&BN_MASK2;
-                                *p=ln;
-                                } while (ln == 0);
-                        }
-                }
-        }
-
-/* n+tn is the word length
- * t needs to be n*4 is size, as does r */
-void bn_mul_part_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int tn,
-             int n, BN_ULONG *t)
-        {
-        int n2=n*2,i,j;
-        int c1;
-        BN_ULONG ln,lo,*p;
-
-#ifdef BN_COUNT
-printf(" bn_mul_part_recursive %d * %d\n",tn+n,tn+n);
-#endif
-        if (n < 8)
-                {
-                i=tn+n;
-                bn_mul_normal(r,a,i,b,i);
-                return;
-                }
-
-        /* r=(a[0]-a[1])*(b[1]-b[0]) */
-        bn_sub_words(t,      a,      &(a[n]),n); /* + */
-        bn_sub_words(&(t[n]),b,      &(b[n]),n); /* - */
-
-        if (n == 8)
-                {
-                bn_mul_comba8(&(t[n2]),t,&(t[n]));
-                bn_mul_comba8(r,a,b);
-                bn_mul_normal(&(r[n2]),&(a[n]),tn,&(b[n]),tn);
-                memset(&(r[n2+tn*2]),0,sizeof(BN_ULONG)*(n2-tn*2));
-                }
-        else
-                {
-                p= &(t[n2*2]);
-                bn_mul_recursive(&(t[n2]),t,&(t[n]),n,p);
-                bn_mul_recursive(r,a,b,n,p);
-                i=n/2;
-                /* If there is only a bottom half to the number,
-                 * just do it */
-                j=tn-i;
-                if (j == 0)
-                        {
-                        bn_mul_recursive(&(r[n2]),&(a[n]),&(b[n]),i,p);
-                        memset(&(r[n2+i*2]),0,sizeof(BN_ULONG)*(n2-i*2));
-                        }
-                else if (j > 0) /* eg, n == 16, i == 8 and tn == 11 */
-                                {
-                                bn_mul_part_recursive(&(r[n2]),&(a[n]),&(b[n]),
-                                        j,i,p);
-                                memset(&(r[n2+tn*2]),0,
-                                        sizeof(BN_ULONG)*(n2-tn*2));
-                                }
-                else /* (j < 0) eg, n == 16, i == 8 and tn == 5 */
-                        {
-                        memset(&(r[n2]),0,sizeof(BN_ULONG)*(tn*2));
-                        for (;;)
-                                {
-                                i/=2;
-                                if (i < tn)
-                                        {
-                                        bn_mul_part_recursive(&(r[n2]),
-                                                &(a[n]),&(b[n]),
-                                                tn-i,i,p);
-                                        break;
-                                        }
-                                else if (i == tn)
-                                        {
-                                        bn_mul_recursive(&(r[n2]),
-                                                &(a[n]),&(b[n]),
-                                                i,p);
-                                        break;
-                                        }
-                                }
-                        }
-                }
-
-        /* t[32] holds (a[0]-a[1])*(b[1]-b[0]), c1 is the sign
-         * r[10] holds (a[0]*b[0])
-         * r[32] holds (b[1]*b[1])
-         */
-
-        c1=bn_add_words(t,r,&(r[n2]),n2);
-        c1-=bn_sub_words(&(t[n2]),t,&(t[n2]),n2);
-
-        /* t[32] holds (a[0]-a[1])*(b[1]-b[0])+(a[0]*b[0])+(a[1]*b[1])
-         * r[10] holds (a[0]*b[0])
-         * r[32] holds (b[1]*b[1])
-         * c1 holds the carry bits
-         */
-        c1+=bn_add_words(&(r[n]),&(r[n]),&(t[n2]),n2);
-        if (c1)
-                {
-                p= &(r[n+n2]);
-                lo= *p;
-                ln=(lo+c1)&BN_MASK2;
-                *p=ln;
-
-                /* The overflow will stop before we over write
-                 * words we should not overwrite */
-                if (ln < c1)
-                        {
-                        do      {
-                                p++;
-                                lo= *p;
-                                ln=(lo+1)&BN_MASK2;
-                                *p=ln;
-                                } while (ln == 0);
-                        }
-                }
-        }
-
-/* r is 2*n words in size,
- * a and b are both n words in size.
- * n must be a power of 2.
- * We multiply and return the result.
- * t must be 2*n words in size
- * We calulate
- * a[0]*b[0]
- * a[0]*b[0]+a[1]*b[1]+(a[0]-a[1])*(b[1]-b[0])
- * a[1]*b[1]
- */
-void bn_sqr_recursive(BN_ULONG *r, BN_ULONG *a, int n2, BN_ULONG *t)
-        {
-        int n=n2/2;
-        int zero,c1;
-        BN_ULONG ln,lo,*p;
-
-#ifdef BN_COUNT
-printf(" bn_sqr_recursive %d * %d\n",n2,n2);
-#endif
-        if (n2 == 4)
-                {
-                bn_sqr_comba4(r,a);
-                return;
-                }
-        else if (n2 == 8)
-                {
-                bn_sqr_comba8(r,a);
-                return;
-                }
-        if (n2 < BN_SQR_RECURSIVE_SIZE_NORMAL)
-                {
-                bn_sqr_normal(r,a,n2,t);
-                return;
-                abort();
-                }
-        /* r=(a[0]-a[1])*(a[1]-a[0]) */
-        c1=bn_cmp_words(a,&(a[n]),n);
-        zero=0;
-        if (c1 > 0)
-                bn_sub_words(t,a,&(a[n]),n);
-        else if (c1 < 0)
-                bn_sub_words(t,&(a[n]),a,n);
-        else
-                zero=1;
-
-        /* The result will always be negative unless it is zero */
-
-        if (n == 8)
-                {
-                if (!zero)
-                        bn_sqr_comba8(&(t[n2]),t);
-                else
-                        memset(&(t[n2]),0,8*sizeof(BN_ULONG));
-                
-                bn_sqr_comba8(r,a);
-                bn_sqr_comba8(&(r[n2]),&(a[n]));
-                }
-        else
-                {
-                p= &(t[n2*2]);
-                if (!zero)
-                        bn_sqr_recursive(&(t[n2]),t,n,p);
-                else
-                        memset(&(t[n2]),0,n*sizeof(BN_ULONG));
-                bn_sqr_recursive(r,a,n,p);
-                bn_sqr_recursive(&(r[n2]),&(a[n]),n,p);
-                }
-
-        /* t[32] holds (a[0]-a[1])*(a[1]-a[0]), it is negative or zero
-         * r[10] holds (a[0]*b[0])
-         * r[32] holds (b[1]*b[1])
-         */
-
-        c1=bn_add_words(t,r,&(r[n2]),n2);
-
-        /* t[32] is negative */
-        c1-=bn_sub_words(&(t[n2]),t,&(t[n2]),n2);
-
-        /* t[32] holds (a[0]-a[1])*(a[1]-a[0])+(a[0]*a[0])+(a[1]*a[1])
-         * r[10] holds (a[0]*a[0])
-         * r[32] holds (a[1]*a[1])
-         * c1 holds the carry bits
-         */
-        c1+=bn_add_words(&(r[n]),&(r[n]),&(t[n2]),n2);
-        if (c1)
-                {
-                p= &(r[n+n2]);
-                lo= *p;
-                ln=(lo+c1)&BN_MASK2;
-                *p=ln;
-
-                /* The overflow will stop before we over write
-                 * words we should not overwrite */
-                if (ln < c1)
-                        {
-                        do      {
-                                p++;
-                                lo= *p;
-                                ln=(lo+1)&BN_MASK2;
-                                *p=ln;
-                                } while (ln == 0);
-                        }
-                }
-        }
-
-#if 1
-/* a and b must be the same size, which is n2.
- * r needs to be n2 words and t needs to be n2*2
- */
-void bn_mul_low_recursive(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n2,
-             BN_ULONG *t)
-        {
-        int n=n2/2;
-
-#ifdef BN_COUNT
-printf(" bn_mul_low_recursive %d * %d\n",n2,n2);
-#endif
-
-        bn_mul_recursive(r,a,b,n,&(t[0]));
-        if (n > BN_MUL_LOW_RECURSIVE_SIZE_NORMAL)
-                {
-                bn_mul_low_recursive(&(t[0]),&(a[0]),&(b[n]),n,&(t[n2]));
-                bn_add_words(&(r[n]),&(r[n]),&(t[0]),n);
-                bn_mul_low_recursive(&(t[0]),&(a[n]),&(b[0]),n,&(t[n2]));
-                bn_add_words(&(r[n]),&(r[n]),&(t[0]),n);
-                }
-        else
-                {
-                bn_mul_low_normal(&(t[0]),&(a[0]),&(b[n]),n);
-                bn_mul_low_normal(&(t[n]),&(a[n]),&(b[0]),n);
-                bn_add_words(&(r[n]),&(r[n]),&(t[0]),n);
-                bn_add_words(&(r[n]),&(r[n]),&(t[n]),n);
-                }
-        }
-
-/* a and b must be the same size, which is n2.
- * r needs to be n2 words and t needs to be n2*2
- * l is the low words of the output.
- * t needs to be n2*3
- */
-void bn_mul_high(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, BN_ULONG *l, int n2,
-             BN_ULONG *t)
-        {
-        int j,i,n,c1,c2;
-        int neg,oneg,zero;
-        BN_ULONG ll,lc,*lp,*mp;
-
-#ifdef BN_COUNT
-printf(" bn_mul_high %d * %d\n",n2,n2);
-#endif
-        n=(n2+1)/2;
-
-        /* Calculate (al-ah)*(bh-bl) */
-        neg=zero=0;
-        c1=bn_cmp_words(&(a[0]),&(a[n]),n);
-        c2=bn_cmp_words(&(b[n]),&(b[0]),n);
-        switch (c1*3+c2)
-                {
-        case -4:
-                bn_sub_words(&(r[0]),&(a[n]),&(a[0]),n);
-                bn_sub_words(&(r[n]),&(b[0]),&(b[n]),n);
-                break;
-        case -3:
-                zero=1;
-                break;
-        case -2:
-                bn_sub_words(&(r[0]),&(a[n]),&(a[0]),n);
-                bn_sub_words(&(r[n]),&(b[n]),&(b[0]),n);
-                neg=1;
-                break;
-        case -1:
-        case 0:
-        case 1:
-                zero=1;
-                break;
-        case 2:
-                bn_sub_words(&(r[0]),&(a[0]),&(a[n]),n);
-                bn_sub_words(&(r[n]),&(b[0]),&(b[n]),n);
-                neg=1;
-                break;
-        case 3:
-                zero=1;
-                break;
-        case 4:
-                bn_sub_words(&(r[0]),&(a[0]),&(a[n]),n);
-                bn_sub_words(&(r[n]),&(b[n]),&(b[0]),n);
-                break;
-                }
-                
-        oneg=neg;
-        /* t[10] = (a[0]-a[1])*(b[1]-b[0]) */
-        bn_mul_recursive(&(t[0]),&(r[0]),&(r[n]),n,&(t[n2]));
-        /* r[10] = (a[1]*b[1]) */
-        bn_mul_recursive(r,&(a[n]),&(b[n]),n,&(t[n2]));
-
-        /* s0 == low(al*bl)
-         * s1 == low(ah*bh)+low((al-ah)*(bh-bl))+low(al*bl)+high(al*bl)
-         * We know s0 and s1 so the only unknown is high(al*bl)
-         * high(al*bl) == s1 - low(ah*bh+s0+(al-ah)*(bh-bl))
-         * high(al*bl) == s1 - (r[0]+l[0]+t[0])
-         */
-        if (l != NULL)
-                {
-                lp= &(t[n2+n]);
-                c1=bn_add_words(lp,&(r[0]),&(l[0]),n);
-                }
-        else
-                {
-                c1=0;
-                lp= &(r[0]);
-                }
-
-        if (neg)
-                neg=bn_sub_words(&(t[n2]),lp,&(t[0]),n);
-        else
-                {
-                bn_add_words(&(t[n2]),lp,&(t[0]),n);
-                neg=0;
-                }
-
-        if (l != NULL)
-                {
-                bn_sub_words(&(t[n2+n]),&(l[n]),&(t[n2]),n);
-                }
-        else
-                {
-                lp= &(t[n2+n]);
-                mp= &(t[n2]);
-                for (i=0; i<n; i++)
-                        lp[i]=((~mp[i])+1)&BN_MASK2;
-                }
-
-        /* s[0] = low(al*bl)
-         * t[3] = high(al*bl)
-         * t[10] = (a[0]-a[1])*(b[1]-b[0]) neg is the sign
-         * r[10] = (a[1]*b[1])
-         */
-        /* R[10] = al*bl
-         * R[21] = al*bl + ah*bh + (a[0]-a[1])*(b[1]-b[0])
-         * R[32] = ah*bh
-         */
-        /* R[1]=t[3]+l[0]+r[0](+-)t[0] (have carry/borrow)
-         * R[2]=r[0]+t[3]+r[1](+-)t[1] (have carry/borrow)
-         * R[3]=r[1]+(carry/borrow)
-         */
-        if (l != NULL)
-                {
-                lp= &(t[n2]);
-                c1= bn_add_words(lp,&(t[n2+n]),&(l[0]),n);
-                }
-        else
-                {
-                lp= &(t[n2+n]);
-                c1=0;
-                }
-        c1+=bn_add_words(&(t[n2]),lp,  &(r[0]),n);
-        if (oneg)
-                c1-=bn_sub_words(&(t[n2]),&(t[n2]),&(t[0]),n);
-        else
-                c1+=bn_add_words(&(t[n2]),&(t[n2]),&(t[0]),n);
-
-        c2 =bn_add_words(&(r[0]),&(r[0]),&(t[n2+n]),n);
-        c2+=bn_add_words(&(r[0]),&(r[0]),&(r[n]),n);
-        if (oneg)
-                c2-=bn_sub_words(&(r[0]),&(r[0]),&(t[n]),n);
-        else
-                c2+=bn_add_words(&(r[0]),&(r[0]),&(t[n]),n);
-        
-        if (c1 != 0) /* Add starting at r[0], could be +ve or -ve */
-                {
-                i=0;
-                if (c1 > 0)
-                        {
-                        lc=c1;
-                        do      {
-                                ll=(r[i]+lc)&BN_MASK2;
-                                r[i++]=ll;
-                                lc=(lc > ll);
-                                } while (lc);
-                        }
-                else
-                        {
-                        lc= -c1;
-                        do      {
-                                ll=r[i];
-                                r[i++]=(ll-lc)&BN_MASK2;
-                                lc=(lc > ll);
-                                } while (lc);
-                        }
-                }
-        if (c2 != 0) /* Add starting at r[1] */
-                {
-                i=n;
-                if (c2 > 0)
-                        {
-                        lc=c2;
-                        do      {
-                                ll=(r[i]+lc)&BN_MASK2;
-                                r[i++]=ll;
-                                lc=(lc > ll);
-                                } while (lc);
-                        }
-                else
-                        {
-                        lc= -c2;
-                        do      {
-                                ll=r[i];
-                                r[i++]=(ll-lc)&BN_MASK2;
-                                lc=(lc > ll);
-                                } while (lc);
-                        }
-                }
-        }
-#endif
diff --git a/src/lib/libcrypto/bn/old/bn_low.c b/src/lib/libcrypto/bn/old/bn_low.c
index cbc406751c..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/bn_low.c
+++ b/src/lib/libcrypto/bn/old/bn_low.c
@@ -1,194 +0,0 @@
-/* crypto/bn/bn_mul.c */
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-#include <stdio.h>
-#include "cryptlib.h"
-#include "bn_lcl.h"
-
-static int bn_mm_low(BIGNUM *m,BIGNUM *A,BIGNUM *B, int num,
-                BIGNUM *sk,BN_CTX *ctx);
-int BN_mul_low(BIGNUM *r, BIGNUM *a, BIGNUM *b,int words);
-
-/* r must be different to a and b */
-int BN_mul_low(BIGNUM *r, BIGNUM *a, BIGNUM *b, int num)
-        {
-        BN_ULONG *ap,*bp,*rp;
-        BIGNUM *sk;
-        int j,i,n,ret;
-        int max,al,bl;
-        BN_CTX ctx;
-
-        bn_check_top(a);
-        bn_check_top(b);
-
-#ifdef BN_MUL_DEBUG
-printf("BN_mul_low(%d,%d,%d)\n",a->top,b->top,num);
-#endif
-
-        al=a->top;
-        bl=b->top;
-        if ((al == 0) || (bl == 0))
-                {
-                r->top=0;
-                return(1);
-                }
-
-        if ((bn_limit_bits_low > 0) && (num > bn_limit_num_low))
-                {
-                n=BN_num_bits_word(num*2)-bn_limit_bits_low;
-                n*=2;
-                sk=(BIGNUM *)Malloc(sizeof(BIGNUM)*n);
-                memset(sk,0,sizeof(BIGNUM)*n);
-                memset(&ctx,0,sizeof(ctx));
-
-                ret=bn_mm_low(r,a,b,num,&(sk[0]),&ctx);
-                for (i=0; i<n; i+=2)
-                        {
-                        BN_clear_free(&sk[i]);
-                        BN_clear_free(&sk[i+1]);
-                        }
-                Free(sk);
-                return(ret);
-                }
-
-        max=(al+bl);
-        if (bn_wexpand(r,max) == NULL) return(0);
-        r->neg=a->neg^b->neg;
-        ap=a->d;
-        bp=b->d;
-        rp=r->d;
-        r->top=(max > num)?num:max;
-
-        rp[al]=bn_mul_words(rp,ap,al,*(bp++));
-        rp++;
-        j=bl;
-        for (i=1; i<j; i++)
-                {
-                if (al >= num--)
-                        {
-                        al--;
-                        if (al <= 0) break;
-                        }
-                rp[al]=bn_mul_add_words(rp,ap,al,*(bp++));
-                rp++;
-                }
-        
-        while ((r->top > 0) && (r->d[r->top-1] == 0))
-                r->top--;
-        return(1);
-        }
-
-
-#define t1      (sk[0])
-#define t2      (sk[1])
-
-/* r must be different to a and b */
-int bn_mm_low(BIGNUM *m, BIGNUM *A, BIGNUM *B, int num, BIGNUM *sk,
-             BN_CTX *ctx)
-        {
-        int n; /* ,sqr=0; */
-        int an,bn;
-        BIGNUM ah,al,bh,bl;
-
-        bn_wexpand(m,num+3);
-        an=A->top;
-        bn=B->top;
-
-#ifdef BN_MUL_DEBUG
-printf("bn_mm_low(%d,%d,%d)\n",A->top,B->top,num);
-#endif
-
-        n=(num+1)/2;
-
-        BN_init(&ah); BN_init(&al); BN_init(&bh); BN_init(&bl);
-
-        bn_set_low( &al,A,n);
-        bn_set_high(&ah,A,n);
-        bn_set_low( &bl,B,n);
-        bn_set_high(&bh,B,n);
-
-        if (num <= (bn_limit_num_low+bn_limit_num_low))
-                {
-                BN_mul(m,&al,&bl);
-                BN_mul_low(&t1,&al,&bh,n);
-                BN_mul_low(&t2,&ah,&bl,n);
-                }
-        else
-                {
-                bn_mm(m  ,&al,&bl,&(sk[2]),ctx);
-                bn_mm_low(&t1,&al,&bh,n,&(sk[2]),ctx);
-                bn_mm_low(&t2,&ah,&bl,n,&(sk[2]),ctx);
-                }
-
-        BN_add(&t1,&t1,&t2);
-
-        /* We will now do an evil hack instead of
-         * BN_lshift(&t1,&t1,n*BN_BITS2);
-         * BN_add(m,m,&t1);
-         * BN_mask_bits(m,num*BN_BITS2);
-         */
-        bn_set_high(&ah,m,n); ah.max=num+2;
-        BN_add(&ah,&ah,&t1);
-        m->top=num;
-
-        m->neg=A->neg^B->neg;
-        return(1);
-        }
-
-#undef t1       (sk[0])
-#undef t2       (sk[1])
diff --git a/src/lib/libcrypto/bn/old/bn_m.c b/src/lib/libcrypto/bn/old/bn_m.c
index 522beb02bc..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/bn_m.c
+++ b/src/lib/libcrypto/bn/old/bn_m.c
@@ -1,139 +0,0 @@
-/* crypto/bn/bn_m.c */
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-#include <stdio.h>
-/*#include "cryptlib.h"*/
-#include "bn_lcl.h"
-
-#define limit_bits 5                    /* 2^5, or 32 words */
-#define limit_num (1<<limit_bits)
-
-int BN_m(BIGNUM *r, BIGNUM *a, BIGNUM *b)
-        {
-        BIGNUM *sk;
-        int i,n;
-
-        n=(BN_num_bits_word(a->top|b->top)-limit_bits);
-        n*=2;
-        sk=(BIGNUM *)malloc(sizeof(BIGNUM)*n);
-        for (i=0; i<n; i++)
-                BN_init(&(sk[i]));
-
-        return(BN_mm(r,a,b,&(sk[0])));
-        }
-
-#define ahal    (sk[0])
-#define blbh    (sk[1])
-
-/* r must be different to a and b */
-int BN_mm(BIGNUM *m, BIGNUM *A, BIGNUM *B, BIGNUM *sk)
-        {
-        int i,num,anum,bnum;
-        int an,bn;
-        BIGNUM ah,al,bh,bl;
-
-        an=A->top;
-        bn=B->top;
-        if ((an <= limit_num) || (bn <= limit_num))
-                {
-                return(BN_mul(m,A,B));
-                }
-
-        anum=(an>bn)?an:bn;
-        num=(anum)/2;
-
-        /* Are going to now chop things into 'num' word chunks. */
-        bnum=num*BN_BITS2;
-
-        BN_init(&ahal);
-        BN_init(&blbh);
-        BN_init(&ah);
-        BN_init(&al);
-        BN_init(&bh);
-        BN_init(&bl);
-
-        al.top=num;
-        al.d=A->d;
-        ah.top=A->top-num;
-        ah.d= &(A->d[num]);
-
-        bl.top=num;
-        bl.d=B->d;
-        bh.top=B->top-num;
-        bh.d= &(B->d[num]);
-
-        BN_sub(&ahal,&ah,&al);
-        BN_sub(&blbh,&bl,&bh);
-
-        BN_mm(m,&ahal,&blbh,&(sk[2]));
-        BN_mm(&ahal,&al,&bl,&(sk[2]));
-        BN_mm(&blbh,&ah,&bh,&(sk[2]));
-
-        BN_add(m,m,&ahal);
-        BN_add(m,m,&blbh);
-
-        BN_lshift(m,m,bnum);
-        BN_add(m,m,&ahal);
-
-        BN_lshift(&blbh,&blbh,bnum*2);
-        BN_add(m,m,&blbh);
-
-        m->neg=A->neg^B->neg;
-        return(1);
-        }
-
diff --git a/src/lib/libcrypto/bn/old/bn_mul.c.works b/src/lib/libcrypto/bn/old/bn_mul.c.works
index 6d565d44a2..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/bn_mul.c.works
+++ b/src/lib/libcrypto/bn/old/bn_mul.c.works
@@ -1,219 +0,0 @@
-/* crypto/bn/bn_mul.c */
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
-#include <stdio.h>
-#include "cryptlib.h"
-#include "bn_lcl.h"
-
-int bn_mm(BIGNUM *m,BIGNUM *A,BIGNUM *B, BIGNUM *sk,BN_CTX *ctx);
-
-/* r must be different to a and b */
-int BN_mul(r, a, b)
-BIGNUM *r;
-BIGNUM *a;
-BIGNUM *b;
-        {
-        BN_ULONG *ap,*bp,*rp;
-        BIGNUM *sk;
-        int i,n,ret;
-        int max,al,bl;
-        BN_CTX ctx;
-
-        bn_check_top(a);
-        bn_check_top(b);
-
-        al=a->top;
-        bl=b->top;
-        if ((al == 0) || (bl == 0))
-                {
-                r->top=0;
-                return(1);
-                }
-#ifdef BN_MUL_DEBUG
-printf("BN_mul(%d,%d)\n",a->top,b->top);
-#endif
-
-#ifdef BN_RECURSION
-        if (    (bn_limit_bits > 0) &&
-                (bl > bn_limit_num) && (al > bn_limit_num))
-                {
-                n=(BN_num_bits_word(al|bl)-bn_limit_bits);
-                n*=2;
-                sk=(BIGNUM *)Malloc(sizeof(BIGNUM)*n);
-                memset(sk,0,sizeof(BIGNUM)*n);
-                memset(&ctx,0,sizeof(ctx));
-
-                ret=bn_mm(r,a,b,&(sk[0]),&ctx);
-                for (i=0; i<n; i+=2)
-                        {
-                        BN_clear_free(&sk[i]);
-                        BN_clear_free(&sk[i+1]);
-                        }
-                Free(sk);
-                return(ret);
-                }
-#endif
-
-        max=(al+bl);
-        if (bn_wexpand(r,max) == NULL) return(0);
-        r->top=max;
-        r->neg=a->neg^b->neg;
-        ap=a->d;
-        bp=b->d;
-        rp=r->d;
-
-#ifdef BN_RECURSION
-        if ((al == bl) && (al == 8))
-                {
-                bn_mul_comba8(rp,ap,bp);
-                }
-        else
-#endif
-                {
-                rp[al]=bn_mul_words(rp,ap,al,*(bp++));
-                rp++;
-                for (i=1; i<bl; i++)
-                        {
-                        rp[al]=bn_mul_add_words(rp,ap,al,*(bp++));
-                        rp++;
-                        }
-                }
-        if ((max > 0) && (r->d[max-1] == 0)) r->top--;
-        return(1);
-        }
-
-#ifdef BN_RECURSION
-
-#define ahal    (sk[0])
-#define blbh    (sk[1])
-
-/* r must be different to a and b */
-int bn_mm(m, A, B, sk,ctx)
-BIGNUM *m,*A,*B;
-BIGNUM *sk;
-BN_CTX *ctx;
-        {
-        int n,num,sqr=0;
-        int an,bn;
-        BIGNUM ah,al,bh,bl;
-
-        an=A->top;
-        bn=B->top;
-#ifdef BN_MUL_DEBUG
-printf("bn_mm(%d,%d)\n",A->top,B->top);
-#endif
-
-        if (A == B) sqr=1;
-        num=(an>bn)?an:bn;
-        n=(num+1)/2;
-        /* Are going to now chop things into 'num' word chunks. */
-
-        BN_init(&ah);
-        BN_init(&al);
-        BN_init(&bh);
-        BN_init(&bl);
-
-        bn_set_low (&al,A,n);
-        bn_set_high(&ah,A,n);
-        bn_set_low (&bl,B,n);
-        bn_set_high(&bh,B,n);
-
-        BN_sub(&ahal,&ah,&al);
-        BN_sub(&blbh,&bl,&bh);
-
-        if (num <= (bn_limit_num+bn_limit_num))
-                {
-                BN_mul(m,&ahal,&blbh);
-                if (sqr)
-                        {
-                        BN_sqr(&ahal,&al,ctx);
-                        BN_sqr(&blbh,&ah,ctx);
-                        }
-                else
-                        {
-                        BN_mul(&ahal,&al,&bl);
-                        BN_mul(&blbh,&ah,&bh);
-                        }
-                }
-        else
-                {
-                bn_mm(m,&ahal,&blbh,&(sk[2]),ctx);
-                bn_mm(&ahal,&al,&bl,&(sk[2]),ctx);
-                bn_mm(&blbh,&ah,&bh,&(sk[2]),ctx);
-                }
-
-        BN_add(m,m,&ahal);
-        BN_add(m,m,&blbh);
-
-        BN_lshift(m,m,n*BN_BITS2);
-        BN_lshift(&blbh,&blbh,n*BN_BITS2*2);
-
-        BN_add(m,m,&ahal);
-        BN_add(m,m,&blbh);
-
-        m->neg=A->neg^B->neg;
-        return(1);
-        }
-#undef ahal     (sk[0])
-#undef blbh     (sk[1])
-
-#include "bn_low.c"
-#include "bn_high.c"
-#include "f.c"
-
-#endif
diff --git a/src/lib/libcrypto/bn/old/bn_wmul.c b/src/lib/libcrypto/bn/old/bn_wmul.c
index a467b2f17a..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/bn_wmul.c
+++ b/src/lib/libcrypto/bn/old/bn_wmul.c
@@ -1,173 +0,0 @@
-#include <stdio.h>
-#include "bn_lcl.h"
-
-#if 1
-
-int bn_mull(BIGNUM *r,BIGNUM *a,BIGNUM *b, BN_CTX *ctx);
-
-int bn_mull(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
-        {
-        int top,i,j,k,al,bl;
-        BIGNUM *t;
-
-#ifdef BN_COUNT
-printf("bn_mull %d * %d\n",a->top,b->top);
-#endif
-
-        bn_check_top(a);
-        bn_check_top(b);
-        bn_check_top(r);
-
-        al=a->top;
-        bl=b->top;
-        r->neg=a->neg^b->neg;
-
-        top=al+bl;
-        if ((al < 4) || (bl < 4))
-                {
-                if (bn_wexpand(r,top) == NULL) return(0);
-                r->top=top;
-                bn_mul_normal(r->d,a->d,al,b->d,bl);
-                goto end;
-                }
-        else if (al == bl) /* A good start, they are the same size */
-                goto symetric;
-        else
-                {
-                i=(al-bl);
-                if ((i ==  1) && !BN_get_flags(b,BN_FLG_STATIC_DATA))
-                        {
-                        bn_wexpand(b,al);
-                        b->d[bl]=0;
-                        bl++;
-                        goto symetric;
-                        }
-                else if ((i ==  -1) && !BN_get_flags(a,BN_FLG_STATIC_DATA))
-                        {
-                        bn_wexpand(a,bl);
-                        a->d[al]=0;
-                        al++;
-                        goto symetric;
-                        }
-                }
-
-        /* asymetric and >= 4 */ 
-        if (bn_wexpand(r,top) == NULL) return(0);
-        r->top=top;
-        bn_mul_normal(r->d,a->d,al,b->d,bl);
-
-        if (0)
-                {
-                /* symetric and > 4 */
-symetric:
-                if (al == 4)
-                        {
-                        if (bn_wexpand(r,al*2) == NULL) return(0);
-                        r->top=top;
-                        bn_mul_comba4(r->d,a->d,b->d);
-                        goto end;
-                        }
-                if (al == 8)
-                        {
-                        if (bn_wexpand(r,al*2) == NULL) return(0);
-                        r->top=top;
-                        bn_mul_comba8(r->d,a->d,b->d);
-                        goto end;
-                        }
-                if (al <= BN_MULL_NORMAL_SIZE)
-                        {
-                        if (bn_wexpand(r,al*2) == NULL) return(0);
-                        r->top=top;
-                        bn_mul_normal(r->d,a->d,al,b->d,bl);
-                        goto end;
-                        }
-                /* 16 or larger */
-                j=BN_num_bits_word((BN_ULONG)al);
-                j=1<<(j-1);
-                k=j+j;
-                t= &(ctx->bn[ctx->tos]);
-                if (al == j) /* exact multiple */
-                        {
-                        bn_wexpand(t,k*2);
-                        bn_wexpand(r,k*2);
-                        bn_mul_recursive(r->d,a->d,b->d,al,t->d);
-                        }
-                else
-                        {
-                        bn_wexpand(a,k);
-                        bn_wexpand(b,k);
-                        bn_wexpand(t,k*4);
-                        bn_wexpand(r,k*4);
-                        for (i=a->top; i<k; i++)
-                                a->d[i]=0;
-                        for (i=b->top; i<k; i++)
-                                b->d[i]=0;
-                        bn_mul_part_recursive(r->d,a->d,b->d,al-j,j,t->d);
-                        }
-                r->top=top;
-                }
-end:
-        bn_fix_top(r);
-        return(1);
-        }
-#endif
-
-void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
-        {
-        BN_ULONG *rr;
-
-#ifdef BN_COUNT
-printf(" bn_mul_normal %d * %d\n",na,nb);
-#endif
-
-        if (na < nb)
-                {
-                int itmp;
-                BN_ULONG *ltmp;
-
-                itmp=na; na=nb; nb=itmp;
-                ltmp=a;   a=b;   b=ltmp;
-
-                }
-        rr= &(r[na]);
-        rr[0]=bn_mul_words(r,a,na,b[0]);
-
-        for (;;)
-                {
-                if (--nb <= 0) return;
-                rr[1]=bn_mul_add_words(&(r[1]),a,na,b[1]);
-                if (--nb <= 0) return;
-                rr[2]=bn_mul_add_words(&(r[2]),a,na,b[2]);
-                if (--nb <= 0) return;
-                rr[3]=bn_mul_add_words(&(r[3]),a,na,b[3]);
-                if (--nb <= 0) return;
-                rr[4]=bn_mul_add_words(&(r[4]),a,na,b[4]);
-                rr+=4;
-                r+=4;
-                b+=4;
-                }
-        }
-
-#if 1
-void bn_mul_low_normal(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n)
-        {
-#ifdef BN_COUNT
-printf(" bn_mul_low_normal %d * %d\n",n,n);
-#endif
-        bn_mul_words(r,a,n,b[0]);
-
-        for (;;)
-                {
-                if (--n <= 0) return;
-                bn_mul_add_words(&(r[1]),a,n,b[1]);
-                if (--n <= 0) return;
-                bn_mul_add_words(&(r[2]),a,n,b[2]);
-                if (--n <= 0) return;
-                bn_mul_add_words(&(r[3]),a,n,b[3]);
-                if (--n <= 0) return;
-                bn_mul_add_words(&(r[4]),a,n,b[4]);
-                r+=4;
-                b+=4;
-                }
-        }
-#endif
diff --git a/src/lib/libcrypto/bn/old/build b/src/lib/libcrypto/bn/old/build
index 8cd99e5f17..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/build
+++ b/src/lib/libcrypto/bn/old/build
@@ -1,3 +0,0 @@
-#!/bin/sh -x
-
-gcc -g -I../../include test.c -L../.. -lcrypto
diff --git a/src/lib/libcrypto/bn/old/info b/src/lib/libcrypto/bn/old/info
index 5ac99c3b23..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/info
+++ b/src/lib/libcrypto/bn/old/info
@@ -1,22 +0,0 @@
-Given A1A0 * B1B0 == S3S2S1S0
-
-S0=     low(A0*B0)
-S1=     low( (A1-A0)*(B0-B1)) +low( A1*B1) +high(A0*B0)
-S2=     high((A1-A0)*(B0-B1)) +high(A1*B1) +low( A1*B1)
-S3=     high(A1*B1);
-
-Assume we know S1 and S0, and can calulate A1*B1 and high((A1-A0)*(B0-B1))
-
-k0=     S0 == low(A0*B0)
-k1=     S1
-k2=     low( A1*B1)
-k3=     high(A1*B1)
-k4=     high((A1-A0)*(B0-B1))
-
-k1=     low((A1-A0)*(B0-B1)) +k2 +high(A0*B0)
-S2=     k4 +k3 +k2
-S3=     k3
-
-S1-k2= low((A1-A0)*(B0-B1)) +high(A0*B0)
-
-We potentially have a carry or a borrow from S1
diff --git a/src/lib/libcrypto/bn/old/test.works b/src/lib/libcrypto/bn/old/test.works
index 127c7b415d..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/old/test.works
+++ b/src/lib/libcrypto/bn/old/test.works
@@ -1,205 +0,0 @@
-#include <stdio.h>
-#include "cryptlib.h"
-#include "bn_lcl.h"
-
-#define SIZE    128
-
-#define BN_MONT_CTX_set         bn_mcs
-#define BN_from_montgomery      bn_fm
-#define BN_mod_mul_montgomery   bn_mmm
-#undef BN_to_montgomery
-#define BN_to_montgomery(r,a,mont,ctx)  bn_mmm(\
-        r,a,(mont)->RR,(mont),ctx)
-
-main()
-        {
-        BIGNUM prime,a,b,r,A,B,R;
-        BN_MONT_CTX *mont;
-        BN_CTX *ctx;
-        int i;
-
-        ctx=BN_CTX_new();
-        BN_init(&prime);
-        BN_init(&a); BN_init(&b); BN_init(&r);
-        BN_init(&A); BN_init(&B); BN_init(&R);
-
-        BN_generate_prime(&prime,SIZE,0,NULL,NULL,NULL,NULL);
-        BN_rand(&A,SIZE,1,0);
-        BN_rand(&B,SIZE,1,0);
-        BN_mod(&A,&A,&prime,ctx);
-        BN_mod(&B,&B,&prime,ctx);
-
-        mont=BN_MONT_CTX_new();
-        BN_MONT_CTX_set(mont,&prime,ctx);
-
-        BN_to_montgomery(&a,&A,mont,ctx);
-        BN_to_montgomery(&b,&B,mont,ctx);
-
-        BN_mul(&r,&a,&b);
-        BN_print_fp(stdout,&r); printf("\n");
-        BN_from_montgomery(&r,&r,mont,ctx);
-        BN_print_fp(stdout,&r); printf("\n");
-        BN_from_montgomery(&r,&r,mont,ctx);
-        BN_print_fp(stdout,&r); printf("\n");
-
-        BN_mod_mul(&R,&A,&B,&prime,ctx);
-
-        BN_print_fp(stdout,&a); printf("\n");
-        BN_print_fp(stdout,&b); printf("\n");
-        BN_print_fp(stdout,&prime); printf("\n");
-        BN_print_fp(stdout,&r); printf("\n\n");
-
-        BN_print_fp(stdout,&A); printf("\n");
-        BN_print_fp(stdout,&B); printf("\n");
-        BN_print_fp(stdout,&prime); printf("\n");
-        BN_print_fp(stdout,&R); printf("\n\n");
-
-        BN_mul(&r,&a,&b);
-        BN_print_fp(stdout,&r); printf(" <- BA*DC\n");
-        BN_copy(&A,&r);
-        i=SIZE/2;
-        BN_mask_bits(&A,i*2);
-//      BN_print_fp(stdout,&A); printf(" <- low(BA*DC)\n");
-        bn_do_lower(&r,&a,&b,&A,i);
-//      BN_print_fp(stdout,&r); printf(" <- low(BA*DC)\n");
-        }
-
-int bn_mul_low(r,a,b,low,i)
-BIGNUM *r,*a,*b,*low;
-int i;
-        {
-        int w;
-        BIGNUM Kh,Km,t1,t2,h,ah,al,bh,bl,l,m,s0,s1;
-
-        BN_init(&Kh); BN_init(&Km); BN_init(&t1); BN_init(&t2); BN_init(&l);
-        BN_init(&ah); BN_init(&al); BN_init(&bh); BN_init(&bl); BN_init(&h);
-        BN_init(&m); BN_init(&s0); BN_init(&s1);
-
-        BN_copy(&al,a); BN_mask_bits(&al,i); BN_rshift(&ah,a,i);
-        BN_copy(&bl,b); BN_mask_bits(&bl,i); BN_rshift(&bh,b,i);
-
-
-        BN_sub(&t1,&al,&ah);
-        BN_sub(&t2,&bh,&bl);
-        BN_mul(&m,&t1,&t2);
-        BN_mul(&h,&ah,&bh);
-
-        BN_copy(&s0,low); BN_mask_bits(&s0,i);
-        BN_rshift(&s1,low,i);
-
-        BN_add(&t1,&h,&m);
-        BN_add(&t1,&t1,&s0);
-
-        BN_copy(&t2,&t1); BN_mask_bits(&t2,i);
-        BN_sub(&t1,&s1,&t2);
-        BN_lshift(&t1,&t1,i);
-        BN_add(&t1,&t1,&s0);
-        if (t1.neg)
-                {
-                BN_lshift(&t2,BN_value_one(),i*2);
-                BN_add(&t1,&t2,&t1);
-                BN_mask_bits(&t1,i*2);
-                }
-        
-        BN_free(&Kh); BN_free(&Km); BN_free(&t1); BN_free(&t2);
-        BN_free(&ah); BN_free(&al); BN_free(&bh); BN_free(&bl);
-        }
-
-int BN_mod_mul_montgomery(r,a,b,mont,ctx)
-BIGNUM *r,*a,*b;
-BN_MONT_CTX *mont;
-BN_CTX *ctx;
-        {
-        BIGNUM *tmp;
-
-        tmp= &(ctx->bn[ctx->tos++]);
-
-        if (a == b)
-                {
-                if (!BN_sqr(tmp,a,ctx)) goto err;
-                }
-        else
-                {
-                if (!BN_mul(tmp,a,b)) goto err;
-                }
-        /* reduce from aRR to aR */
-        if (!BN_from_montgomery(r,tmp,mont,ctx)) goto err;
-        ctx->tos--;
-        return(1);
-err:
-        return(0);
-        }
-
-int BN_from_montgomery(r,a,mont,ctx)
-BIGNUM *r;
-BIGNUM *a;
-BN_MONT_CTX *mont;
-BN_CTX *ctx;
-        {
-        BIGNUM z1;
-        BIGNUM *t1,*t2;
-        BN_ULONG *ap,*bp,*rp;
-        int j,i,bl,al;
-
-        BN_init(&z1);
-        t1= &(ctx->bn[ctx->tos]);
-        t2= &(ctx->bn[ctx->tos+1]);
-
-        if (!BN_copy(t1,a)) goto err;
-        /* can cheat */
-        BN_mask_bits(t1,mont->ri);
-        if (!BN_mul(t2,t1,mont->Ni)) goto err;
-        BN_mask_bits(t2,mont->ri);
-
-        if (!BN_mul(t1,t2,mont->N)) goto err;
-        if (!BN_add(t2,t1,a)) goto err;
-
-        /* At this point, t2 has the bottom ri bits set to zero.
-         * This means that the bottom ri bits == the 1^ri minus the bottom
-         * ri bits of a.
-         * This means that only the bits above 'ri' in a need to be added,
-         * and XXXXXXXXXXXXXXXXXXXXXXXX
-         */
-BN_print_fp(stdout,t2); printf("\n");
-        BN_rshift(r,t2,mont->ri);
-
-        if (BN_ucmp(r,mont->N) >= 0)
-                bn_qsub(r,r,mont->N);
-
-        return(1);
-err:
-        return(0);
-        }
-
-int BN_MONT_CTX_set(mont,mod,ctx)
-BN_MONT_CTX *mont;
-BIGNUM *mod;
-BN_CTX *ctx;
-        {
-        BIGNUM *Ri=NULL,*R=NULL;
-
-        if (mont->RR == NULL) mont->RR=BN_new();
-        if (mont->N == NULL)  mont->N=BN_new();
-
-        R=mont->RR;                                     /* grab RR as a temp */
-        BN_copy(mont->N,mod);                           /* Set N */
-
-        mont->ri=(BN_num_bits(mod)+(BN_BITS2-1))/BN_BITS2*BN_BITS2;
-        BN_lshift(R,BN_value_one(),mont->ri);                   /* R */
-        if ((Ri=BN_mod_inverse(NULL,R,mod,ctx)) == NULL) goto err;/* Ri */
-        BN_lshift(Ri,Ri,mont->ri);                              /* R*Ri */
-        bn_qsub(Ri,Ri,BN_value_one());                          /* R*Ri - 1 */
-        BN_div(Ri,NULL,Ri,mod,ctx);
-        if (mont->Ni != NULL) BN_free(mont->Ni);
-        mont->Ni=Ri;                                    /* Ni=(R*Ri-1)/N */
-
-        /* setup RR for conversions */
-        BN_lshift(mont->RR,BN_value_one(),mont->ri*2);
-        BN_mod(mont->RR,mont->RR,mont->N,ctx);
-
-        return(1);
-err:
-        return(0);
-        }
-
-
diff --git a/src/lib/libcrypto/bn/test.c b/src/lib/libcrypto/bn/test.c
index a048b9f878..e69de29bb2 100644
--- a/src/lib/libcrypto/bn/test.c
+++ b/src/lib/libcrypto/bn/test.c
@@ -1,241 +0,0 @@
-#include <stdio.h>
-#include "cryptlib.h"
-#include "bn_lcl.h"
-
-#define SIZE    32
-
-#define BN_MONT_CTX_set         bn_mcs
-#define BN_from_montgomery      bn_fm
-#define BN_mod_mul_montgomery   bn_mmm
-#undef BN_to_montgomery
-#define BN_to_montgomery(r,a,mont,ctx)  bn_mmm(\
-        r,a,(mont)->RR,(mont),ctx)
-
-main()
-        {
-        BIGNUM prime,a,b,r,A,B,R;
-        BN_MONT_CTX *mont;
-        BN_CTX *ctx;
-        int i;
-
-        ctx=BN_CTX_new();
-        BN_init(&prime);
-        BN_init(&a); BN_init(&b); BN_init(&r);
-        BN_init(&A); BN_init(&B); BN_init(&R);
-
-        BN_generate_prime(&prime,SIZE,0,NULL,NULL,NULL,NULL);
-        BN_rand(&A,SIZE,1,0);
-        BN_rand(&B,SIZE,1,0);
-        BN_mod(&A,&A,&prime,ctx);
-        BN_mod(&B,&B,&prime,ctx);
-
-        i=A.top;
-        BN_mul(&R,&A,&B,ctx);
-        BN_mask_bits(&R,i*BN_BITS2);
-
-
-        BN_print_fp(stdout,&A); printf(" <- a\n");
-        BN_print_fp(stdout,&B); printf(" <- b\n");
-        BN_mul_high(&r,&A,&B,&R,i);
-        BN_print_fp(stdout,&r); printf(" <- high(BA*DC)\n");
-
-        BN_mask_bits(&A,i*32);
-        BN_mask_bits(&B,i*32);
-
-        BN_mul(&R,&A,&B);
-        BN_rshift(&R,&R,i*32);
-        BN_print_fp(stdout,&R); printf(" <- norm BA*DC\n");
-        BN_sub(&R,&R,&r);
-        BN_print_fp(stdout,&R); printf(" <- diff\n");
-        }
-
-#if 0
-int bn_mul_high(BIGNUM *r, BIGNUM *a, BIGNUM *b, BIGNUM *low, int words)
-        {
-        int i;
-        BIGNUM t1,t2,t3,h,ah,al,bh,bl,m,s0,s1;
-
-        BN_init(&al); BN_init(&ah);
-        BN_init(&bl); BN_init(&bh);
-        BN_init(&t1); BN_init(&t2); BN_init(&t3);
-        BN_init(&s0); BN_init(&s1);
-        BN_init(&h); BN_init(&m);
-
-        i=a->top;
-        if (i >= words)
-                {
-                al.top=words;
-                ah.top=a->top-words;
-                ah.d= &(a->d[ah.top]);
-                }
-        else
-                al.top=i;
-        al.d=a->d;
-
-        i=b->top;
-        if (i >= words)
-                {
-                bl.top=words;
-                bh.top=i-words;
-                bh.d= &(b->d[bh.top]);
-                }
-        else
-                bl.top=i;
-        bl.d=b->d;
-
-        i=low->top;
-        if (i >= words)
-                {
-                s0.top=words;
-                s1.top=i-words;
-                s1.d= &(low->d[s1.top]);
-                }
-        else
-                s0.top=i;
-        s0.d=low->d;
-
-al.max=al.top; ah.max=ah.top;
-bl.max=bl.top; bh.max=bh.top;
-s0.max=bl.top; s1.max=bh.top;
-
-        /* Calculate (al-ah)*(bh-bl) */
-        BN_sub(&t1,&al,&ah);
-        BN_sub(&t2,&bh,&bl);
-        BN_mul(&m,&t1,&t2);
-
-        /* Calculate ah*bh */
-        BN_mul(&h,&ah,&bh);
-
-        /* s0 == low(al*bl)
-         * s1 == low(ah*bh)+low((al-ah)*(bh-bl))+low(al*bl)+high(al*bl)
-         * We know s0 and s1 so the only unknown is high(al*bl)
-         * high(al*bl) == s1 - low(ah*bh+(al-ah)*(bh-bl)+s0)
-         */
-        BN_add(&m,&m,&h);
-        BN_add(&t2,&m,&s0);
-        /* Quick and dirty mask off of high words */
-        t3.d=t2.d;
-        t3.top=(t2.top > words)?words:t2.top;
-        t3.neg=t2.neg;
-t3.max=t3.top;
-/* BN_print_fp(stdout,&s1); printf(" s1\n"); */
-/* BN_print_fp(stdout,&t2); printf(" middle value\n"); */
-/* BN_print_fp(stdout,&t3); printf(" low middle value\n"); */
-        BN_sub(&t1,&s1,&t3);
-
-        if (t1.neg)
-                {
-/*printf("neg fixup\n"); BN_print_fp(stdout,&t1); printf(" before\n"); */
-                BN_lshift(&t2,BN_value_one(),words*32);
-                BN_add(&t1,&t2,&t1);
-                BN_mask_bits(&t1,words*32);
-/* BN_print_fp(stdout,&t1); printf(" after\n"); */
-                }
-        /* al*bl == high(al*bl)<<words+s0 */
-        BN_lshift(&t1,&t1,words*32);
-        BN_add(&t1,&t1,&s0);
-        
-        /* We now have
-         * al*bl                        - t1
-         * (al-ah)*(bh-bl)+ah*bh        - m
-         * ah*bh                        - h
-         */
-        BN_copy(r,&t1);
-        BN_mask_bits(r,words*32*2);
-
-        /*BN_lshift(&m,&m,words*/
-
-        BN_free(&t1); BN_free(&t2);
-        BN_free(&m); BN_free(&h);
-        }
-
-int BN_mod_mul_montgomery(BIGNUM *r, BIGNUM *a, BIGNUM *b, BN_MONT_CTX *mont,
-             BN_CTX *ctx)
-        {
-        BIGNUM *tmp;
-
-        tmp= &(ctx->bn[ctx->tos++]);
-
-        if (a == b)
-                {
-                if (!BN_sqr(tmp,a,ctx)) goto err;
-                }
-        else
-                {
-                if (!BN_mul(tmp,a,b)) goto err;
-                }
-        /* reduce from aRR to aR */
-        if (!BN_from_montgomery(r,tmp,mont,ctx)) goto err;
-        ctx->tos--;
-        return(1);
-err:
-        return(0);
-        }
-
-int BN_from_montgomery(BIGNUM *r, BIGNUM *a, BN_MONT_CTX *mont, BN_CTX *ctx)
-        {
-        BIGNUM z1;
-        BIGNUM *t1,*t2;
-        BN_ULONG *ap,*bp,*rp;
-        int j,i,bl,al;
-
-        BN_init(&z1);
-        t1= &(ctx->bn[ctx->tos]);
-        t2= &(ctx->bn[ctx->tos+1]);
-
-        if (!BN_copy(t1,a)) goto err;
-        /* can cheat */
-        BN_mask_bits(t1,mont->ri);
-        if (!BN_mul(t2,t1,mont->Ni)) goto err;
-        BN_mask_bits(t2,mont->ri);
-
-        if (!BN_mul(t1,t2,mont->N)) goto err;
-        if (!BN_add(t2,t1,a)) goto err;
-
-        /* At this point, t2 has the bottom ri bits set to zero.
-         * This means that the bottom ri bits == the 1^ri minus the bottom
-         * ri bits of a.
-         * This means that only the bits above 'ri' in a need to be added,
-         * and XXXXXXXXXXXXXXXXXXXXXXXX
-         */
-BN_print_fp(stdout,t2); printf("\n");
-        BN_rshift(r,t2,mont->ri);
-
-        if (BN_ucmp(r,mont->N) >= 0)
-                BN_usub(r,r,mont->N);
-
-        return(1);
-err:
-        return(0);
-        }
-
-int BN_MONT_CTX_set(BN_MONT_CTX *mont, BIGNUM *mod, BN_CTX *ctx)
-        {
-        BIGNUM *Ri=NULL,*R=NULL;
-
-        if (mont->RR == NULL) mont->RR=BN_new();
-        if (mont->N == NULL)  mont->N=BN_new();
-
-        R=mont->RR;                                     /* grab RR as a temp */
-        BN_copy(mont->N,mod);                           /* Set N */
-
-        mont->ri=(BN_num_bits(mod)+(BN_BITS2-1))/BN_BITS2*BN_BITS2;
-        BN_lshift(R,BN_value_one(),mont->ri);                   /* R */
-        if ((Ri=BN_mod_inverse(NULL,R,mod,ctx)) == NULL) goto err;/* Ri */
-        BN_lshift(Ri,Ri,mont->ri);                              /* R*Ri */
-        BN_usub(Ri,Ri,BN_value_one());                          /* R*Ri - 1 */
-        BN_div(Ri,NULL,Ri,mod,ctx);
-        if (mont->Ni != NULL) BN_free(mont->Ni);
-        mont->Ni=Ri;                                    /* Ni=(R*Ri-1)/N */
-
-        /* setup RR for conversions */
-        BN_lshift(mont->RR,BN_value_one(),mont->ri*2);
-        BN_mod(mont->RR,mont->RR,mont->N,ctx);
-
-        return(1);
-err:
-        return(0);
-        }
-
-
-#endif