- Speedup 3DES by using assembly code for i386.

- Sync des/blowfish to more recent openssl.

Obtained from:	KAME/NetBSD
MFC after:	2 weeks

15 files changed, 5195 insertions, 508 deletions

diff --git a/sys/crypto/blowfish/arch/i386/bf_enc.S b/sys/crypto/blowfish/arch/i386/bf_enc.S
new file mode 100644
index 0000000..a261e55
--- /dev/null
+++ b/sys/crypto/blowfish/arch/i386/bf_enc.S
@@ -0,0 +1,17 @@
+/*	$NetBSD: bf_enc.S,v 1.1 2001/09/09 11:01:01 tls Exp $	*/
+/*	$FreeBSD$	*/
+
+/*
+ * Written by Jason R. Thorpe <thorpej@zembu.com> and Thor Lancelot Simon
+ * <tls@netbsd.org>.  Public domain.
+ */
+
+/*
+ * XXX Should use CPP symbols defined as a result of
+ * XXX `cc -mcpu=pentiumpro'.
+ */
+#if defined(I386_CPU) || defined(I486_CPU) || defined(I586_CPU)
+#include "bf_enc_586.S"
+#else
+#include "bf_enc_686.S"
+#endif
diff --git a/sys/crypto/blowfish/arch/i386/bf_enc_586.S b/sys/crypto/blowfish/arch/i386/bf_enc_586.S
new file mode 100644
index 0000000..f6b3cef
--- /dev/null
+++ b/sys/crypto/blowfish/arch/i386/bf_enc_586.S
@@ -0,0 +1,762 @@
+/*	$NetBSD: bf_enc_586.S,v 1.1 2001/09/09 11:01:01 tls Exp $	*/
+/*	$FreeBSD$	*/
+
+/* 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.]
+ */
+
+/*
+ * Modified from the output of `perl bf-586.pl elf' by
+ * Jason R. Thorpe <thorpej@zembu.com> and Thor Lancelot Simon
+ * <tls@netbsd.org>
+ */
+
+#include <i386/include/asm.h>
+#define	_C_LABEL	CNAME
+
+ENTRY(BF_encrypt)
+	pushl	%ebp
+	pushl	%ebx
+	movl	12(%esp),	%ebx
+	movl	16(%esp),	%ebp
+	pushl	%esi
+	pushl	%edi
+	/* Load the 2 words */
+	movl	(%ebx),		%edi
+	movl	4(%ebx),	%esi
+	xorl	%eax,		%eax
+	movl	(%ebp),		%ebx
+	xorl	%ecx,		%ecx
+	xorl	%ebx,		%edi
+
+	/* Round 0 */
+	movl	4(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 1 */
+	movl	8(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 2 */
+	movl	12(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 3 */
+	movl	16(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 4 */
+	movl	20(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 5 */
+	movl	24(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 6 */
+	movl	28(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 7 */
+	movl	32(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 8 */
+	movl	36(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 9 */
+	movl	40(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 10 */
+	movl	44(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 11 */
+	movl	48(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 12 */
+	movl	52(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 13 */
+	movl	56(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 14 */
+	movl	60(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 15 */
+	movl	64(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	# Load parameter 0 (16) enc=1 
+	movl	20(%esp),	%eax
+	xorl	%ebx,		%edi
+	movl	68(%ebp),	%edx
+	xorl	%edx,		%esi
+	movl	%edi,		4(%eax)
+	movl	%esi,		(%eax)
+	popl	%edi
+	popl	%esi
+	popl	%ebx
+	popl	%ebp
+	ret
+.L_BF_encrypt_end:
+	.size   _C_LABEL(BF_encrypt),.L_BF_encrypt_end-_C_LABEL(BF_encrypt)
+
+ENTRY(BF_decrypt)
+	pushl	%ebp
+	pushl	%ebx
+	movl	12(%esp),	%ebx
+	movl	16(%esp),	%ebp
+	pushl	%esi
+	pushl	%edi
+	# Load the 2 words 
+	movl	(%ebx),		%edi
+	movl	4(%ebx),	%esi
+	xorl	%eax,		%eax
+	movl	68(%ebp),	%ebx
+	xorl	%ecx,		%ecx
+	xorl	%ebx,		%edi
+
+	/* Round 16 */
+	movl	64(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 15 */
+	movl	60(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 14 */
+	movl	56(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 13 */
+	movl	52(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 12 */
+	movl	48(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 11 */
+	movl	44(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 10 */
+	movl	40(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 9 */
+	movl	36(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 8 */
+	movl	32(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 7 */
+	movl	28(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 6 */
+	movl	24(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 5 */
+	movl	20(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 4 */
+	movl	16(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 3 */
+	movl	12(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%edi
+
+	/* Round 2 */
+	movl	8(%ebp),	%edx
+	movl	%edi,		%ebx
+	xorl	%edx,		%esi
+	shrl	$16,		%ebx
+	movl	%edi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	xorl	%eax,		%eax
+	xorl	%ebx,		%esi
+
+	/* Round 1 */
+	movl	4(%ebp),	%edx
+	movl	%esi,		%ebx
+	xorl	%edx,		%edi
+	shrl	$16,		%ebx
+	movl	%esi,		%edx
+	movb	%bh,		%al
+	andl	$255,		%ebx
+	movb	%dh,		%cl
+	andl	$255,		%edx
+	movl	72(%ebp,%eax,4),%eax
+	movl	1096(%ebp,%ebx,4),%ebx
+	addl	%eax,		%ebx
+	movl	2120(%ebp,%ecx,4),%eax
+	xorl	%eax,		%ebx
+	movl	3144(%ebp,%edx,4),%edx
+	addl	%edx,		%ebx
+	# Load parameter 0 (1) enc=0 
+	movl	20(%esp),	%eax
+	xorl	%ebx,		%edi
+	movl	(%ebp),		%edx
+	xorl	%edx,		%esi
+	movl	%edi,		4(%eax)
+	movl	%esi,		(%eax)
+	popl	%edi
+	popl	%esi
+	popl	%ebx
+	popl	%ebp
+	ret
+.L_BF_decrypt_end:
+	.size   _C_LABEL(BF_decrypt),.L_BF_decrypt_end-_C_LABEL(BF_decrypt)
diff --git a/sys/crypto/blowfish/arch/i386/bf_enc_686.S b/sys/crypto/blowfish/arch/i386/bf_enc_686.S
new file mode 100644
index 0000000..e480e65
--- /dev/null
+++ b/sys/crypto/blowfish/arch/i386/bf_enc_686.S
@@ -0,0 +1,734 @@
+/*	$NetBSD: bf_enc_686.S,v 1.1 2001/09/09 11:01:02 tls Exp $	*/
+/*	$FreeBSD$	*/
+
+/* 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.]
+ */
+
+/*
+ * Modified from the output of `perl bf-686.pl elf' by
+ * Jason R. Thorpe <thorpej@zembu.com> and Thor Lancelot Simon
+ * <tls@netbsd.org>
+ */
+
+#include <i386/include/asm.h>
+#define	_C_LABEL	CNAME
+
+ENTRY(BF_encrypt)
+	pushl	%ebp
+	pushl	%ebx
+	pushl	%esi
+	pushl	%edi
+
+
+	/* Load the 2 words */
+	movl	20(%esp),	%eax
+	movl	(%eax),		%ecx
+	movl	4(%eax),	%edx
+
+	/* P pointer, s and enc flag */
+	movl	24(%esp),	%edi
+	xorl	%eax,		%eax
+	xorl	%ebx,		%ebx
+	xorl	(%edi),		%ecx
+
+	/* Round 0 */
+	rorl	$16,		%ecx
+	movl	4(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 1 */
+	rorl	$16,		%edx
+	movl	8(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 2 */
+	rorl	$16,		%ecx
+	movl	12(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 3 */
+	rorl	$16,		%edx
+	movl	16(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 4 */
+	rorl	$16,		%ecx
+	movl	20(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 5 */
+	rorl	$16,		%edx
+	movl	24(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 6 */
+	rorl	$16,		%ecx
+	movl	28(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 7 */
+	rorl	$16,		%edx
+	movl	32(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 8 */
+	rorl	$16,		%ecx
+	movl	36(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 9 */
+	rorl	$16,		%edx
+	movl	40(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 10 */
+	rorl	$16,		%ecx
+	movl	44(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 11 */
+	rorl	$16,		%edx
+	movl	48(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 12 */
+	rorl	$16,		%ecx
+	movl	52(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 13 */
+	rorl	$16,		%edx
+	movl	56(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 14 */
+	rorl	$16,		%ecx
+	movl	60(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 15 */
+	rorl	$16,		%edx
+	movl	64(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+	xorl	68(%edi),	%edx
+	movl	20(%esp),	%eax
+	movl	%edx,		(%eax)
+	movl	%ecx,		4(%eax)
+	popl	%edi
+	popl	%esi
+	popl	%ebx
+	popl	%ebp
+	ret
+.L_BF_encrypt_end:
+	.size   _C_LABEL(BF_encrypt),.L_BF_encrypt_end-_C_LABEL(BF_encrypt)
+
+ENTRY(BF_decrypt)
+	pushl	%ebp
+	pushl	%ebx
+	pushl	%esi
+	pushl	%edi
+
+
+	/* Load the 2 words */
+	movl	20(%esp),	%eax
+	movl	(%eax),		%ecx
+	movl	4(%eax),	%edx
+
+	/* P pointer, s and enc flag */
+	movl	24(%esp),	%edi
+	xorl	%eax,		%eax
+	xorl	%ebx,		%ebx
+	xorl	68(%edi),	%ecx
+
+	/* Round 16 */
+	rorl	$16,		%ecx
+	movl	64(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 15 */
+	rorl	$16,		%edx
+	movl	60(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 14 */
+	rorl	$16,		%ecx
+	movl	56(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 13 */
+	rorl	$16,		%edx
+	movl	52(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 12 */
+	rorl	$16,		%ecx
+	movl	48(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 11 */
+	rorl	$16,		%edx
+	movl	44(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 10 */
+	rorl	$16,		%ecx
+	movl	40(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 9 */
+	rorl	$16,		%edx
+	movl	36(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 8 */
+	rorl	$16,		%ecx
+	movl	32(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 7 */
+	rorl	$16,		%edx
+	movl	28(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 6 */
+	rorl	$16,		%ecx
+	movl	24(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 5 */
+	rorl	$16,		%edx
+	movl	20(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 4 */
+	rorl	$16,		%ecx
+	movl	16(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 3 */
+	rorl	$16,		%edx
+	movl	12(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+
+	/* Round 2 */
+	rorl	$16,		%ecx
+	movl	8(%edi),	%esi
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	rorl	$16,		%ecx
+	xorl	%esi,		%edx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%ch,		%al
+	movb	%cl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%edx
+
+	/* Round 1 */
+	rorl	$16,		%edx
+	movl	4(%edi),	%esi
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	rorl	$16,		%edx
+	xorl	%esi,		%ecx
+	movl	72(%edi,%eax,4),%esi
+	movl	1096(%edi,%ebx,4),%ebp
+	movb	%dh,		%al
+	movb	%dl,		%bl
+	addl	%ebp,		%esi
+	movl	2120(%edi,%eax,4),%eax
+	xorl	%eax,		%esi
+	movl	3144(%edi,%ebx,4),%ebp
+	addl	%ebp,		%esi
+	xorl	%eax,		%eax
+	xorl	%esi,		%ecx
+	xorl	(%edi),		%edx
+	movl	20(%esp),	%eax
+	movl	%edx,		(%eax)
+	movl	%ecx,		4(%eax)
+	popl	%edi
+	popl	%esi
+	popl	%ebx
+	popl	%ebp
+	ret
+	.L_BF_decrypt_end:
+	.size   _C_LABEL(BF_decrypt),.L_BF_decrypt_end-_C_LABEL(BF_decrypt)
diff --git a/sys/crypto/blowfish/bf_enc.c b/sys/crypto/blowfish/bf_enc.c
index 5edd6db..831db17 100644
--- a/sys/crypto/blowfish/bf_enc.c
+++ b/sys/crypto/blowfish/bf_enc.c
@@ -1,12 +1,12 @@
 /*	$FreeBSD$	*/
-/*	$KAME: bf_enc.c,v 1.5 2000/09/18 21:21:19 itojun Exp $	*/
+/*	$KAME: bf_enc.c,v 1.7 2002/02/27 01:33:59 itojun Exp $	*/
 
 /* crypto/bf/bf_enc.c */
-/* 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@mincom.oz.au).
+ * 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
@@ -14,7 +14,7 @@
  * 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@mincom.oz.au).
+ * 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.
@@ -34,12 +34,12 @@
  * 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@mincom.oz.au)"
+ *     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@mincom.oz.au)"
+ *    "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
@@ -75,10 +75,9 @@ to modify the code.
 
 /* XXX "data" is host endian */
 void
-BF_encrypt(data, key, encrypt)
+BF_encrypt(data, key)
 	BF_LONG *data;
 	BF_KEY *key;
-	int encrypt;
 {
 	register BF_LONG l, r, *p, *s;
 
@@ -87,57 +86,73 @@ BF_encrypt(data, key, encrypt)
 	l = data[0];
 	r = data[1];
 
-	if (encrypt) {
-		l^=p[0];
-		BF_ENC(r, l, s, p[ 1]);
-		BF_ENC(l, r, s, p[ 2]);
-		BF_ENC(r, l, s, p[ 3]);
-		BF_ENC(l, r, s, p[ 4]);
-		BF_ENC(r, l, s, p[ 5]);
-		BF_ENC(l, r, s, p[ 6]);
-		BF_ENC(r, l, s, p[ 7]);
-		BF_ENC(l, r, s, p[ 8]);
-		BF_ENC(r, l, s, p[ 9]);
-		BF_ENC(l, r, s, p[10]);
-		BF_ENC(r, l, s, p[11]);
-		BF_ENC(l, r, s, p[12]);
-		BF_ENC(r, l, s, p[13]);
-		BF_ENC(l, r, s, p[14]);
-		BF_ENC(r, l, s, p[15]);
-		BF_ENC(l, r, s, p[16]);
+	l^=p[0];
+	BF_ENC(r, l, s, p[ 1]);
+	BF_ENC(l, r, s, p[ 2]);
+	BF_ENC(r, l, s, p[ 3]);
+	BF_ENC(l, r, s, p[ 4]);
+	BF_ENC(r, l, s, p[ 5]);
+	BF_ENC(l, r, s, p[ 6]);
+	BF_ENC(r, l, s, p[ 7]);
+	BF_ENC(l, r, s, p[ 8]);
+	BF_ENC(r, l, s, p[ 9]);
+	BF_ENC(l, r, s, p[10]);
+	BF_ENC(r, l, s, p[11]);
+	BF_ENC(l, r, s, p[12]);
+	BF_ENC(r, l, s, p[13]);
+	BF_ENC(l, r, s, p[14]);
+	BF_ENC(r, l, s, p[15]);
+	BF_ENC(l, r, s, p[16]);
 #if BF_ROUNDS == 20
-		BF_ENC(r, l, s, p[17]);
-		BF_ENC(l, r, s, p[18]);
-		BF_ENC(r, l, s, p[19]);
-		BF_ENC(l, r, s, p[20]);
+	BF_ENC(r, l, s, p[17]);
+	BF_ENC(l, r, s, p[18]);
+	BF_ENC(r, l, s, p[19]);
+	BF_ENC(l, r, s, p[20]);
 #endif
-		r ^= p[BF_ROUNDS + 1];
-	} else {
-		l ^= p[BF_ROUNDS + 1];
+	r ^= p[BF_ROUNDS + 1];
+
+	data[1] = l & 0xffffffff;
+	data[0] = r & 0xffffffff;
+}
+
+/* XXX "data" is host endian */
+void
+BF_decrypt(data, key)
+	BF_LONG *data;
+	BF_KEY *key;
+{
+	register BF_LONG l, r, *p, *s;
+
+	p = key->P;
+	s= &key->S[0];
+	l = data[0];
+	r = data[1];
+
+	l ^= p[BF_ROUNDS + 1];
 #if BF_ROUNDS == 20
-		BF_ENC(r, l, s, p[20]);
-		BF_ENC(l, r, s, p[19]);
-		BF_ENC(r, l, s, p[18]);
-		BF_ENC(l, r, s, p[17]);
+	BF_ENC(r, l, s, p[20]);
+	BF_ENC(l, r, s, p[19]);
+	BF_ENC(r, l, s, p[18]);
+	BF_ENC(l, r, s, p[17]);
 #endif
-		BF_ENC(r, l, s, p[16]);
-		BF_ENC(l, r, s, p[15]);
-		BF_ENC(r, l, s, p[14]);
-		BF_ENC(l, r, s, p[13]);
-		BF_ENC(r, l, s, p[12]);
-		BF_ENC(l, r, s, p[11]);
-		BF_ENC(r, l, s, p[10]);
-		BF_ENC(l, r, s, p[ 9]);
-		BF_ENC(r, l, s, p[ 8]);
-		BF_ENC(l, r, s, p[ 7]);
-		BF_ENC(r, l, s, p[ 6]);
-		BF_ENC(l, r, s, p[ 5]);
-		BF_ENC(r, l, s, p[ 4]);
-		BF_ENC(l, r, s, p[ 3]);
-		BF_ENC(r, l, s, p[ 2]);
-		BF_ENC(l, r, s, p[ 1]);
-		r ^= p[0];
-	}
+	BF_ENC(r, l, s, p[16]);
+	BF_ENC(l, r, s, p[15]);
+	BF_ENC(r, l, s, p[14]);
+	BF_ENC(l, r, s, p[13]);
+	BF_ENC(r, l, s, p[12]);
+	BF_ENC(l, r, s, p[11]);
+	BF_ENC(r, l, s, p[10]);
+	BF_ENC(l, r, s, p[ 9]);
+	BF_ENC(r, l, s, p[ 8]);
+	BF_ENC(l, r, s, p[ 7]);
+	BF_ENC(r, l, s, p[ 6]);
+	BF_ENC(l, r, s, p[ 5]);
+	BF_ENC(r, l, s, p[ 4]);
+	BF_ENC(l, r, s, p[ 3]);
+	BF_ENC(r, l, s, p[ 2]);
+	BF_ENC(l, r, s, p[ 1]);
+	r ^= p[0];
+
 	data[1] = l & 0xffffffff;
 	data[0] = r & 0xffffffff;
 }
diff --git a/sys/crypto/blowfish/bf_locl.h b/sys/crypto/blowfish/bf_locl.h
index 52585bb..9314ff3 100644
--- a/sys/crypto/blowfish/bf_locl.h
+++ b/sys/crypto/blowfish/bf_locl.h
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$KAME: bf_locl.h,v 1.5 2000/08/31 06:03:48 itojun Exp $	*/
+/*	$KAME: bf_locl.h,v 1.6 2001/09/10 04:03:56 itojun Exp $	*/
 
 /* crypto/bf/bf_local.h */
 /* Copyright (C) 1995-1997 Eric Young (eay@mincom.oz.au)
@@ -163,7 +163,6 @@
  */
 #undef	BF_PTR
 #undef	BF_PTR2
-#ifdef __NetBSD__
 #ifdef __i386__
 #define	BF_PTR2
 #else
@@ -171,7 +170,6 @@
 #define	BF_PTR
 #endif
 #endif
-#endif /*NetBSD*/
 
 #define BF_M	0x3fc
 #define BF_0	22L
diff --git a/sys/crypto/blowfish/bf_pi.h b/sys/crypto/blowfish/bf_pi.h
index 8982aac..fdd5a27 100644
--- a/sys/crypto/blowfish/bf_pi.h
+++ b/sys/crypto/blowfish/bf_pi.h
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$KAME: bf_pi.h,v 1.3 2000/03/27 04:36:26 sumikawa Exp $	*/
+/*	$KAME: bf_pi.h,v 1.4 2001/09/10 04:03:56 itojun Exp $	*/
 
 /* crypto/bf/bf_pi.h */
 /* Copyright (C) 1995-1997 Eric Young (eay@mincom.oz.au)
@@ -59,7 +59,7 @@
  * [including the GNU Public Licence.]
  */
 
-static BF_KEY bf_init= {
+static const BF_KEY bf_init= {
 	{
 	0x243f6a88L, 0x85a308d3L, 0x13198a2eL, 0x03707344L,
 	0xa4093822L, 0x299f31d0L, 0x082efa98L, 0xec4e6c89L,
diff --git a/sys/crypto/blowfish/bf_skey.c b/sys/crypto/blowfish/bf_skey.c
index 4bbe036..a93558c 100644
--- a/sys/crypto/blowfish/bf_skey.c
+++ b/sys/crypto/blowfish/bf_skey.c
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$KAME: bf_skey.c,v 1.5 2000/11/06 13:58:08 itojun Exp $	*/
+/*	$KAME: bf_skey.c,v 1.7 2002/02/27 01:33:59 itojun Exp $	*/
 
 /* crypto/bf/bf_skey.c */
 /* Copyright (C) 1995-1997 Eric Young (eay@mincom.oz.au)
@@ -76,7 +76,7 @@ BF_set_key(key, len, data)
 	BF_LONG *p, ri, in[2];
 	unsigned char *d, *end;
 
-	memcpy((char *)key, (char *)&bf_init, sizeof(BF_KEY));
+	memcpy((char *)key, (const char *)&bf_init, sizeof(BF_KEY));
 	p = key->P;
 
 	if (len > ((BF_ROUNDS + 2) * 4))
@@ -106,14 +106,14 @@ BF_set_key(key, len, data)
 	in[0] = 0L;
 	in[1] = 0L;
 	for (i = 0; i < BF_ROUNDS + 2; i += 2) {
-		BF_encrypt(in, key, BF_ENCRYPT);
+		BF_encrypt(in, key);
 		p[i  ] = in[0];
 		p[i+1] = in[1];
 	}
 
 	p = key->S;
 	for (i = 0; i < 4 * 256; i += 2) {
-		BF_encrypt(in, key, BF_ENCRYPT);
+		BF_encrypt(in, key);
 		p[i  ] = in[0];
 		p[i+1] = in[1];
 	}
diff --git a/sys/crypto/blowfish/blowfish.h b/sys/crypto/blowfish/blowfish.h
index 76605f8..26b3e7c 100644
--- a/sys/crypto/blowfish/blowfish.h
+++ b/sys/crypto/blowfish/blowfish.h
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$KAME: blowfish.h,v 1.10 2000/09/18 21:21:20 itojun Exp $	*/
+/*	$KAME: blowfish.h,v 1.12 2002/02/27 01:33:59 itojun Exp $	*/
 
 /* crypto/bf/blowfish.h */
 /* Copyright (C) 1995-1997 Eric Young (eay@mincom.oz.au)
@@ -81,7 +81,11 @@ typedef struct bf_key_st {
 } BF_KEY;
 
 void BF_set_key __P((BF_KEY *, int, unsigned char *));
-void BF_encrypt __P((BF_LONG *, BF_KEY *, int));
+void BF_encrypt __P((BF_LONG *, BF_KEY *));
+void BF_decrypt __P((BF_LONG *, BF_KEY *));
+void BF_cbc_encrypt(const unsigned char *, unsigned char *, long,
+		    const BF_KEY *, unsigned char *, int);
+
 #ifdef  __cplusplus
 }
 #endif
diff --git a/sys/crypto/des/arch/i386/des_enc.S b/sys/crypto/des/arch/i386/des_enc.S
new file mode 100644
index 0000000..ed49a0b
--- /dev/null
+++ b/sys/crypto/des/arch/i386/des_enc.S
@@ -0,0 +1,2815 @@
+/* $NetBSD: des_enc.S,v 1.1 2001/09/09 11:01:02 tls Exp $ */
+/* $FreeBSD$ */
+
+/* Copyright (C) 1995-1997 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.]
+ */
+
+/*
+ * Modified from the output of `perl des686.pl elf' by 
+ * Thor Lancelot Simon <tls@netbsd.org>
+ */
+
+#include <i386/include/asm.h>
+#define	_C_LABEL	CNAME
+
+ENTRY(des_encrypt1)
+	pushl	%esi
+	pushl	%edi
+
+	# Load the 2 words 
+	movl	12(%esp),	%esi
+	xorl	%ecx,		%ecx
+	pushl	%ebx
+	pushl	%ebp
+	movl	(%esi),		%eax
+	movl	28(%esp),	%ebx
+	movl	4(%esi),	%edi
+
+	# IP 
+	roll	$4,		%eax
+	movl	%eax,		%esi
+	xorl	%edi,		%eax
+	andl	$0xf0f0f0f0,	%eax
+	xorl	%eax,		%esi
+	xorl	%eax,		%edi
+
+	roll	$20,		%edi
+	movl	%edi,		%eax
+	xorl	%esi,		%edi
+	andl	$0xfff0000f,	%edi
+	xorl	%edi,		%eax
+	xorl	%edi,		%esi
+
+	roll	$14,		%eax
+	movl	%eax,		%edi
+	xorl	%esi,		%eax
+	andl	$0x33333333,	%eax
+	xorl	%eax,		%edi
+	xorl	%eax,		%esi
+
+	roll	$22,		%esi
+	movl	%esi,		%eax
+	xorl	%edi,		%esi
+	andl	$0x03fc03fc,	%esi
+	xorl	%esi,		%eax
+	xorl	%esi,		%edi
+
+	roll	$9,		%eax
+	movl	%eax,		%esi
+	xorl	%edi,		%eax
+	andl	$0xaaaaaaaa,	%eax
+	xorl	%eax,		%esi
+	xorl	%eax,		%edi
+
+.byte 209
+.byte 199		# roll $1 %edi 
+	movl	24(%esp),	%ebp
+	cmpl	$0,		%ebx
+	je	.L000start_decrypt
+
+	# Round 0 
+	movl	(%ebp),		%eax
+	xorl	%ebx,		%ebx
+	movl	4(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 1 
+	movl	8(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	12(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 2 
+	movl	16(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	20(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 3 
+	movl	24(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	28(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 4 
+	movl	32(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	36(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 5 
+	movl	40(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	44(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 6 
+	movl	48(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	52(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 7 
+	movl	56(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	60(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 8 
+	movl	64(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	68(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 9 
+	movl	72(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	76(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 10 
+	movl	80(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	84(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 11 
+	movl	88(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	92(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 12 
+	movl	96(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	100(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 13 
+	movl	104(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	108(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 14 
+	movl	112(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	116(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 15 
+	movl	120(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	124(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+	jmp	.L001end
+.L000start_decrypt:
+
+	# Round 15 
+	movl	120(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	124(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 14 
+	movl	112(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	116(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 13 
+	movl	104(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	108(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 12 
+	movl	96(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	100(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 11 
+	movl	88(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	92(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 10 
+	movl	80(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	84(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 9 
+	movl	72(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	76(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 8 
+	movl	64(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	68(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 7 
+	movl	56(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	60(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 6 
+	movl	48(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	52(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 5 
+	movl	40(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	44(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 4 
+	movl	32(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	36(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 3 
+	movl	24(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	28(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 2 
+	movl	16(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	20(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 1 
+	movl	8(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	12(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 0 
+	movl	(%ebp),		%eax
+	xorl	%ebx,		%ebx
+	movl	4(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+.L001end:
+
+	# FP 
+	movl	20(%esp),	%edx
+.byte 209
+.byte 206		# rorl $1 %esi 
+	movl	%edi,		%eax
+	xorl	%esi,		%edi
+	andl	$0xaaaaaaaa,	%edi
+	xorl	%edi,		%eax
+	xorl	%edi,		%esi
+
+	roll	$23,		%eax
+	movl	%eax,		%edi
+	xorl	%esi,		%eax
+	andl	$0x03fc03fc,	%eax
+	xorl	%eax,		%edi
+	xorl	%eax,		%esi
+
+	roll	$10,		%edi
+	movl	%edi,		%eax
+	xorl	%esi,		%edi
+	andl	$0x33333333,	%edi
+	xorl	%edi,		%eax
+	xorl	%edi,		%esi
+
+	roll	$18,		%esi
+	movl	%esi,		%edi
+	xorl	%eax,		%esi
+	andl	$0xfff0000f,	%esi
+	xorl	%esi,		%edi
+	xorl	%esi,		%eax
+
+	roll	$12,		%edi
+	movl	%edi,		%esi
+	xorl	%eax,		%edi
+	andl	$0xf0f0f0f0,	%edi
+	xorl	%edi,		%esi
+	xorl	%edi,		%eax
+
+	rorl	$4,		%eax
+	movl	%eax,		(%edx)
+	movl	%esi,		4(%edx)
+	popl	%ebp
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	ret
+.L_des_encrypt1_end:
+	.size	_C_LABEL(des_encrypt1),.L_des_encrypt1_end-_C_LABEL(des_encrypt1)
+
+ENTRY(des_encrypt2)
+	pushl	%esi
+	pushl	%edi
+
+	# Load the 2 words 
+	movl	12(%esp),	%eax
+	xorl	%ecx,		%ecx
+	pushl	%ebx
+	pushl	%ebp
+	movl	(%eax),		%esi
+	movl	28(%esp),	%ebx
+	roll	$3,		%esi
+	movl	4(%eax),	%edi
+	roll	$3,		%edi
+	movl	24(%esp),	%ebp
+	cmpl	$0,		%ebx
+	je	.L002start_decrypt
+
+	# Round 0 
+	movl	(%ebp),		%eax
+	xorl	%ebx,		%ebx
+	movl	4(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 1 
+	movl	8(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	12(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 2 
+	movl	16(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	20(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 3 
+	movl	24(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	28(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 4 
+	movl	32(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	36(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 5 
+	movl	40(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	44(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 6 
+	movl	48(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	52(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 7 
+	movl	56(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	60(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 8 
+	movl	64(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	68(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 9 
+	movl	72(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	76(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 10 
+	movl	80(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	84(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 11 
+	movl	88(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	92(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 12 
+	movl	96(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	100(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 13 
+	movl	104(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	108(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 14 
+	movl	112(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	116(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 15 
+	movl	120(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	124(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+	jmp	.L003end
+.L002start_decrypt:
+
+	# Round 15 
+	movl	120(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	124(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 14 
+	movl	112(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	116(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 13 
+	movl	104(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	108(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 12 
+	movl	96(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	100(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 11 
+	movl	88(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	92(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 10 
+	movl	80(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	84(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 9 
+	movl	72(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	76(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 8 
+	movl	64(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	68(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 7 
+	movl	56(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	60(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 6 
+	movl	48(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	52(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 5 
+	movl	40(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	44(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 4 
+	movl	32(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	36(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 3 
+	movl	24(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	28(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 2 
+	movl	16(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	20(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+
+	# Round 1 
+	movl	8(%ebp),	%eax
+	xorl	%ebx,		%ebx
+	movl	12(%ebp),	%edx
+	xorl	%esi,		%eax
+	xorl	%esi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%edi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%edi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%edi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%edi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%edi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%edi
+
+	# Round 0 
+	movl	(%ebp),		%eax
+	xorl	%ebx,		%ebx
+	movl	4(%ebp),	%edx
+	xorl	%edi,		%eax
+	xorl	%edi,		%edx
+	andl	$0xfcfcfcfc,	%eax
+	andl	$0xcfcfcfcf,	%edx
+	movb	%al,		%bl
+	movb	%ah,		%cl
+	rorl	$4,		%edx
+	movl	      _C_LABEL(des_SPtrans)(%ebx),%ebp
+	movb	%dl,		%bl
+	xorl	%ebp,		%esi
+	movl	0x200+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movb	%dh,		%cl
+	shrl	$16,		%eax
+	movl	0x100+_C_LABEL(des_SPtrans)(%ebx),%ebp
+	xorl	%ebp,		%esi
+	movb	%ah,		%bl
+	shrl	$16,		%edx
+	movl	0x300+_C_LABEL(des_SPtrans)(%ecx),%ebp
+	xorl	%ebp,		%esi
+	movl	24(%esp),	%ebp
+	movb	%dh,		%cl
+	andl	$0xff,		%eax
+	andl	$0xff,		%edx
+	movl	0x600+_C_LABEL(des_SPtrans)(%ebx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x700+_C_LABEL(des_SPtrans)(%ecx),%ebx
+	xorl	%ebx,		%esi
+	movl	0x400+_C_LABEL(des_SPtrans)(%eax),%ebx
+	xorl	%ebx,		%esi
+	movl	0x500+_C_LABEL(des_SPtrans)(%edx),%ebx
+	xorl	%ebx,		%esi
+.L003end:
+
+	# Fixup 
+	rorl	$3,		%edi
+	movl	20(%esp),	%eax
+	rorl	$3,		%esi
+	movl	%edi,		(%eax)
+	movl	%esi,		4(%eax)
+	popl	%ebp
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+	ret
+.L_des_encrypt2_end:
+	.size	_C_LABEL(des_encrypt2),.L_des_encrypt2_end-_C_LABEL(des_encrypt2)
+
+ENTRY(des_encrypt3)
+	pushl   %ebx
+	movl    8(%esp),        %ebx
+	pushl   %ebp
+	pushl   %esi
+	pushl   %edi
+
+	# Load the data words 
+	movl    (%ebx),         %edi
+	movl    4(%ebx),        %esi
+	subl    $12,            %esp
+
+	# IP 
+	roll    $4,             %edi
+	movl    %edi,           %edx
+	xorl    %esi,           %edi
+	andl    $0xf0f0f0f0,    %edi
+	xorl    %edi,           %edx
+	xorl    %edi,           %esi
+
+	roll    $20,            %esi
+	movl    %esi,           %edi
+	xorl    %edx,           %esi
+	andl    $0xfff0000f,    %esi
+	xorl    %esi,           %edi
+	xorl    %esi,           %edx
+
+	roll    $14,            %edi
+	movl    %edi,           %esi
+	xorl    %edx,           %edi
+	andl    $0x33333333,    %edi
+	xorl    %edi,           %esi
+	xorl    %edi,           %edx
+
+	roll    $22,            %edx
+	movl    %edx,           %edi
+	xorl    %esi,           %edx
+	andl    $0x03fc03fc,    %edx
+	xorl    %edx,           %edi
+	xorl    %edx,           %esi
+
+	roll    $9,             %edi
+	movl    %edi,           %edx
+	xorl    %esi,           %edi
+	andl    $0xaaaaaaaa,    %edi
+	xorl    %edi,           %edx
+	xorl    %edi,           %esi
+
+	rorl    $3,             %edx
+	rorl    $2,             %esi
+	movl    %esi,           4(%ebx)
+	movl    36(%esp),       %eax
+	movl    %edx,           (%ebx)
+	movl    40(%esp),       %edi
+	movl    44(%esp),       %esi
+	movl    $1,             8(%esp)
+	movl    %eax,           4(%esp)
+	movl    %ebx,           (%esp)
+	call    _C_LABEL(des_encrypt2)
+	movl    $0,             8(%esp)
+	movl    %edi,           4(%esp)
+	movl    %ebx,           (%esp)
+	call    _C_LABEL(des_encrypt2)
+	movl    $1,             8(%esp)
+	movl    %esi,           4(%esp)
+	movl    %ebx,           (%esp)
+	call    _C_LABEL(des_encrypt2)
+	addl    $12,            %esp
+	movl    (%ebx),         %edi
+	movl    4(%ebx),        %esi
+
+	# FP 
+	roll    $2,             %esi
+	roll    $3,             %edi
+	movl    %edi,           %eax
+	xorl    %esi,           %edi
+	andl    $0xaaaaaaaa,    %edi
+	xorl    %edi,           %eax
+	xorl    %edi,           %esi
+
+	roll    $23,            %eax
+	movl    %eax,           %edi
+	xorl    %esi,           %eax
+	andl    $0x03fc03fc,    %eax
+	xorl    %eax,           %edi
+	xorl    %eax,           %esi
+
+	roll    $10,            %edi
+	movl    %edi,           %eax
+	xorl    %esi,           %edi
+	andl    $0x33333333,    %edi
+	xorl    %edi,           %eax
+	xorl    %edi,           %esi
+
+	roll    $18,            %esi
+	movl    %esi,           %edi
+	xorl    %eax,           %esi
+	andl    $0xfff0000f,    %esi
+	xorl    %esi,           %edi
+	xorl    %esi,           %eax
+
+	roll    $12,            %edi
+	movl    %edi,           %esi
+	xorl    %eax,           %edi
+	andl    $0xf0f0f0f0,    %edi
+	xorl    %edi,           %esi
+	xorl    %edi,           %eax
+
+	rorl    $4,             %eax
+	movl    %eax,           (%ebx)
+	movl    %esi,           4(%ebx)
+	popl    %edi
+	popl    %esi
+	popl    %ebp
+	popl    %ebx
+	ret
+.L_des_encrypt3_end:
+        .size   _C_LABEL(des_encrypt3),.L_des_encrypt3_end-_C_LABEL(des_encrypt3)
+
+ENTRY(des_decrypt3)
+	pushl   %ebx
+	movl    8(%esp),        %ebx
+	pushl   %ebp
+	pushl   %esi
+	pushl   %edi
+
+	# Load the data words 
+	movl    (%ebx),         %edi
+	movl    4(%ebx),        %esi
+	subl    $12,            %esp
+
+	# IP 
+	roll    $4,             %edi
+	movl    %edi,           %edx
+	xorl    %esi,           %edi
+	andl    $0xf0f0f0f0,    %edi
+	xorl    %edi,           %edx
+	xorl    %edi,           %esi
+
+	roll    $20,            %esi
+	movl    %esi,           %edi
+	xorl    %edx,           %esi
+	andl    $0xfff0000f,    %esi
+	xorl    %esi,           %edi
+	xorl    %esi,           %edx
+
+	roll    $14,            %edi
+	movl    %edi,           %esi
+	xorl    %edx,           %edi
+	andl    $0x33333333,    %edi
+	xorl    %edi,           %esi
+	xorl    %edi,           %edx
+
+	roll    $22,            %edx
+	movl    %edx,           %edi
+	xorl    %esi,           %edx
+	andl    $0x03fc03fc,    %edx
+	xorl    %edx,           %edi
+	xorl    %edx,           %esi
+
+	roll    $9,             %edi
+	movl    %edi,           %edx
+	xorl    %esi,           %edi
+	andl    $0xaaaaaaaa,    %edi
+	xorl    %edi,           %edx
+	xorl    %edi,           %esi
+
+	rorl    $3,             %edx
+	rorl    $2,             %esi
+	movl    %esi,           4(%ebx)
+	movl    36(%esp),       %esi
+	movl    %edx,           (%ebx)
+	movl    40(%esp),       %edi
+	movl    44(%esp),       %eax
+	movl    $0,             8(%esp)
+	movl    %eax,           4(%esp)
+	movl    %ebx,           (%esp)
+	call    _C_LABEL(des_encrypt2)
+	movl    $1,             8(%esp)
+	movl    %edi,           4(%esp)
+	movl    %ebx,           (%esp)
+	call    _C_LABEL(des_encrypt2)
+	movl    $0,             8(%esp)
+	movl    %esi,           4(%esp)
+	movl    %ebx,           (%esp)
+	call    _C_LABEL(des_encrypt2)
+	addl    $12,            %esp
+	movl    (%ebx),         %edi
+	movl    4(%ebx),        %esi
+
+	# FP 
+	roll    $2,             %esi
+	roll    $3,             %edi
+	movl    %edi,           %eax
+	xorl    %esi,           %edi
+	andl    $0xaaaaaaaa,    %edi
+	xorl    %edi,           %eax
+	xorl    %edi,           %esi
+
+	roll    $23,            %eax
+	movl    %eax,           %edi
+	xorl    %esi,           %eax
+	andl    $0x03fc03fc,    %eax
+	xorl    %eax,           %edi
+	xorl    %eax,           %esi
+
+	roll    $10,            %edi
+	movl    %edi,           %eax
+	xorl    %esi,           %edi
+	andl    $0x33333333,    %edi
+	xorl    %edi,           %eax
+	xorl    %edi,           %esi
+
+	roll    $18,            %esi
+	movl    %esi,           %edi
+	xorl    %eax,           %esi
+	andl    $0xfff0000f,    %esi
+	xorl    %esi,           %edi
+	xorl    %esi,           %eax
+
+	roll    $12,            %edi
+	movl    %edi,           %esi
+	xorl    %eax,           %edi
+	andl    $0xf0f0f0f0,    %edi
+	xorl    %edi,           %esi
+	xorl    %edi,           %eax
+
+        rorl    $4,             %eax
+	movl    %eax,           (%ebx)
+	movl    %esi,           4(%ebx)
+	popl    %edi
+	popl    %esi
+	popl    %ebp
+	popl    %ebx
+	ret
+.L_des_decrypt3_end:
+	.size   _C_LABEL(des_decrypt3),.L_des_decrypt3_end-_C_LABEL(des_decrypt3)
diff --git a/sys/crypto/des/des.h b/sys/crypto/des/des.h
index c21f972..1eaa16c 100644
--- a/sys/crypto/des/des.h
+++ b/sys/crypto/des/des.h
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$KAME: des.h,v 1.7 2000/09/18 20:59:21 itojun Exp $	*/
+/*	$KAME: des.h,v 1.8 2001/09/10 04:03:57 itojun Exp $	*/
 
 /* lib/des/des.h */
 /* Copyright (C) 1995-1996 Eric Young (eay@mincom.oz.au)
@@ -61,15 +61,14 @@ extern "C" {
 typedef unsigned char des_cblock[8];
 typedef struct des_ks_struct
 	{
-	union	{
-		des_cblock _;
-		/* make sure things are correct size on machines with
-		 * 8 byte longs */
-		DES_LONG pad[2];
-		} ks;
-#undef _
-#define _	ks._
-	} des_key_schedule[16];
+	union   {
+	des_cblock cblock;
+	/* make sure things are correct size on machines with
+	 * 8 byte longs */
+	DES_LONG deslong[2];
+	} ks;
+	int weak_key;
+} des_key_schedule[16];
 
 #define DES_KEY_SZ 	(sizeof(des_cblock))
 #define DES_SCHEDULE_SZ (sizeof(des_key_schedule))
@@ -85,13 +84,32 @@ extern int des_check_key;	/* defaults to false */
 char *des_options __P((void));
 void des_ecb_encrypt __P((des_cblock *, des_cblock *,
 	des_key_schedule, int));
-void des_encrypt __P((DES_LONG *, des_key_schedule, int));
+
+void des_encrypt1 __P((DES_LONG *, des_key_schedule, int));
 void des_encrypt2 __P((DES_LONG *, des_key_schedule, int));
+void des_encrypt3 __P((DES_LONG *, des_key_schedule, des_key_schedule,
+		      des_key_schedule));
+void des_decrypt3 __P((DES_LONG *, des_key_schedule, des_key_schedule,
+		      des_key_schedule));
+
+void des_ecb3_encrypt __P((des_cblock *, des_cblock *, des_key_schedule, 
+			  des_key_schedule, des_key_schedule, int));
+
+void des_ncbc_encrypt __P((const unsigned char *, unsigned char *, long,
+			  des_key_schedule, des_cblock *, int));
+
+void des_ede3_cbc_encrypt(const unsigned char *, unsigned char *, long,
+			  des_key_schedule, des_key_schedule, 
+			  des_key_schedule, des_cblock *, int);
 
 void des_set_odd_parity __P((des_cblock *));
+void des_fixup_key_parity __P((des_cblock *)); 
 int des_is_weak_key __P((des_cblock *));
 int des_set_key __P((des_cblock *, des_key_schedule));
 int des_key_sched __P((des_cblock *, des_key_schedule));
+int des_set_key_checked __P((des_cblock *, des_key_schedule));
+void des_set_key_unchecked __P((des_cblock *, des_key_schedule));
+int des_check_key_parity __P((des_cblock *));
 
 #ifdef  __cplusplus
 }
diff --git a/sys/crypto/des/des_ecb.c b/sys/crypto/des/des_ecb.c
index aa1b22b..6d815fc 100644
--- a/sys/crypto/des/des_ecb.c
+++ b/sys/crypto/des/des_ecb.c
@@ -1,8 +1,8 @@
 /*	$FreeBSD$	*/
-/*	$KAME: des_ecb.c,v 1.5 2000/11/06 13:58:08 itojun Exp $	*/
+/*	$KAME: des_ecb.c,v 1.6 2001/09/10 04:03:58 itojun Exp $	*/
 
 /* crypto/des/ecb_enc.c */
-/* Copyright (C) 1995-1996 Eric Young (eay@mincom.oz.au)
+/* Copyright (C) 1995-1998 Eric Young (eay@mincom.oz.au)
  * All rights reserved.
  *
  * This file is part of an SSL implementation written
@@ -53,182 +53,84 @@
 #include <crypto/des/des_locl.h>
 #include <crypto/des/spr.h>
 
-char *libdes_version="libdes v 3.24 - 20-Apr-1996 - eay";
-char *DES_version="DES part of SSLeay 0.6.4 30-Aug-1996";
+/* char *libdes_version="libdes v 3.24 - 20-Apr-1996 - eay"; */ /* wrong */
+/* char *DES_version="DES part of SSLeay 0.6.4 30-Aug-1996"; */
+
+char *des_options(void)
+        {
+        static int init=1;
+        static char buf[32];
+
+        if (init)
+                {
+                const char *ptr,*unroll,*risc,*size;
 
-char *des_options()
-	{
 #ifdef DES_PTR
-	if (sizeof(DES_LONG) != sizeof(long))
-		return("des(ptr,int)");
-	else
-		return("des(ptr,long)");
+                ptr="ptr";
 #else
-	if (sizeof(DES_LONG) != sizeof(long))
-		return("des(idx,int)");
-	else
-		return("des(idx,long)");
+                ptr="idx";
 #endif
-	}
-		
-
-void des_ecb_encrypt(input, output, ks, encrypt)
-des_cblock (*input);
-des_cblock (*output);
-des_key_schedule ks;
-int encrypt;
-	{
+#if defined(DES_RISC1) || defined(DES_RISC2)
+#ifdef DES_RISC1
+                risc="risc1";
+#endif
+#ifdef DES_RISC2
+                risc="risc2";
+#endif
+#else
+                risc="cisc";
+#endif
+#ifdef DES_UNROLL
+                unroll="16";
+#else
+                unroll="4";
+#endif
+                if (sizeof(DES_LONG) != sizeof(long))
+                        size="int";
+                else
+                        size="long";
+                sprintf(buf,"des(%s,%s,%s,%s)",ptr,risc,unroll,size);
+                init=0;
+                }
+        return(buf);
+}
+void des_ecb_encrypt(des_cblock *input, des_cblock *output, 
+		     des_key_schedule ks, int enc)
+{
 	register DES_LONG l;
-	register unsigned char *in,*out;
 	DES_LONG ll[2];
+	const unsigned char *in=&(*input)[0];
+	unsigned char *out = &(*output)[0];
 
-	in=(unsigned char *)input;
-	out=(unsigned char *)output;
 	c2l(in,l); ll[0]=l;
 	c2l(in,l); ll[1]=l;
-	des_encrypt(ll,ks,encrypt);
+	des_encrypt1(ll,ks,enc);
 	l=ll[0]; l2c(l,out);
 	l=ll[1]; l2c(l,out);
 	l=ll[0]=ll[1]=0;
-	}
-
-void des_encrypt(data, ks, encrypt)
-DES_LONG *data;
-des_key_schedule ks;
-int encrypt;
-	{
-	register DES_LONG l,r,t,u;
-#ifdef DES_PTR
-	register unsigned char *des_SP=(unsigned char *)des_SPtrans;
-#endif
-#ifdef undef
-	union fudge {
-		DES_LONG  l;
-		unsigned short s[2];
-		unsigned char  c[4];
-		} U,T;
-#endif
-	register int i;
-	register DES_LONG *s;
+}
 
-	u=data[0];
-	r=data[1];
-
-	IP(u,r);
-	/* Things have been modified so that the initial rotate is
-	 * done outside the loop.  This required the
-	 * des_SPtrans values in sp.h to be rotated 1 bit to the right.
-	 * One perl script later and things have a 5% speed up on a sparc2.
-	 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
-	 * for pointing this out. */
-	l=(r<<1)|(r>>31);
-	r=(u<<1)|(u>>31);
-
-	/* clear the top bits on machines with 8byte longs */
-	l&=0xffffffffL;
-	r&=0xffffffffL;
-
-	s=(DES_LONG *)ks;
-	/* I don't know if it is worth the effort of loop unrolling the
-	 * inner loop
-	 */
-	if (encrypt)
-		{
-		for (i=0; i<32; i+=8)
-			{
-			D_ENCRYPT(l,r,i+0); /*  1 */
-			D_ENCRYPT(r,l,i+2); /*  2 */
-			D_ENCRYPT(l,r,i+4); /*  3 */
-			D_ENCRYPT(r,l,i+6); /*  4 */
-			}
-		}
-	else
-		{
-		for (i=30; i>0; i-=8)
-			{
-			D_ENCRYPT(l,r,i-0); /* 16 */
-			D_ENCRYPT(r,l,i-2); /* 15 */
-			D_ENCRYPT(l,r,i-4); /* 14 */
-			D_ENCRYPT(r,l,i-6); /* 13 */
-			}
-		}
-	l=(l>>1)|(l<<31);
-	r=(r>>1)|(r<<31);
-	/* clear the top bits on machines with 8byte longs */
-	l&=0xffffffffL;
-	r&=0xffffffffL;
-
-	FP(r,l);
-	data[0]=l;
-	data[1]=r;
-	l=r=t=u=0;
-	}
-
-void des_encrypt2(data, ks, encrypt)
-DES_LONG *data;
-des_key_schedule ks;
-int encrypt;
-	{
-	register DES_LONG l,r,t,u;
-#ifdef DES_PTR
-	register unsigned char *des_SP=(unsigned char *)des_SPtrans;
-#endif
-#ifdef undef
-	union fudge {
-		DES_LONG  l;
-		unsigned short s[2];
-		unsigned char  c[4];
-		} U,T;
-#endif
-	register int i;
-	register DES_LONG *s;
-
-	u=data[0];
-	r=data[1];
-
-	/* Things have been modified so that the initial rotate is
-	 * done outside the loop.  This required the
-	 * des_SPtrans values in sp.h to be rotated 1 bit to the right.
-	 * One perl script later and things have a 5% speed up on a sparc2.
-	 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
-	 * for pointing this out. */
-	l=(r<<1)|(r>>31);
-	r=(u<<1)|(u>>31);
-
-	/* clear the top bits on machines with 8byte longs */
-	l&=0xffffffffL;
-	r&=0xffffffffL;
-
-	s=(DES_LONG *)ks;
-	/* I don't know if it is worth the effort of loop unrolling the
-	 * inner loop */
-	if (encrypt)
-		{
-		for (i=0; i<32; i+=8)
-			{
-			D_ENCRYPT(l,r,i+0); /*  1 */
-			D_ENCRYPT(r,l,i+2); /*  2 */
-			D_ENCRYPT(l,r,i+4); /*  3 */
-			D_ENCRYPT(r,l,i+6); /*  4 */
-			}
-		}
+void des_ecb3_encrypt(des_cblock *input, des_cblock *output,
+             des_key_schedule ks1, des_key_schedule ks2, des_key_schedule ks3,
+             int enc)
+{
+	register DES_LONG l0,l1;
+	DES_LONG ll[2];
+	const unsigned char *in = &(*input)[0];
+	unsigned char *out = &(*output)[0];
+ 
+	c2l(in,l0); 
+	c2l(in,l1);
+	ll[0]=l0; 
+	ll[1]=l1;
+
+	if (enc)
+		des_encrypt3(ll,ks1,ks2,ks3);
 	else
-		{
-		for (i=30; i>0; i-=8)
-			{
-			D_ENCRYPT(l,r,i-0); /* 16 */
-			D_ENCRYPT(r,l,i-2); /* 15 */
-			D_ENCRYPT(l,r,i-4); /* 14 */
-			D_ENCRYPT(r,l,i-6); /* 13 */
-			}
-		}
-	l=(l>>1)|(l<<31);
-	r=(r>>1)|(r<<31);
-	/* clear the top bits on machines with 8byte longs */
-	l&=0xffffffffL;
-	r&=0xffffffffL;
+		des_decrypt3(ll,ks1,ks2,ks3);
 
-	data[0]=l;
-	data[1]=r;
-	l=r=t=u=0;
-	}
+	l0=ll[0];
+	l1=ll[1];
+	l2c(l0,out);
+	l2c(l1,out);
+}
diff --git a/sys/crypto/des/des_enc.c b/sys/crypto/des/des_enc.c
new file mode 100644
index 0000000..6a91a88
--- /dev/null
+++ b/sys/crypto/des/des_enc.c
@@ -0,0 +1,294 @@
+/*	$KAME: des_enc.c,v 1.1 2001/09/10 04:03:58 itojun Exp $	*/
+/*	$FreeBSD$	*/
+
+/* crypto/des/des_enc.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 <sys/types.h>
+#include <crypto/des/des_locl.h>
+
+extern	const DES_LONG des_SPtrans[8][64];
+
+void des_encrypt1(DES_LONG *data, des_key_schedule ks, int enc)
+{
+	register DES_LONG l,r,t,u;
+#ifdef DES_PTR
+	register const unsigned char *des_SP=(const unsigned char *)des_SPtrans;
+#endif
+#ifndef DES_UNROLL
+	register int i;
+#endif
+	register DES_LONG *s;
+
+	r=data[0];
+	l=data[1];
+
+	IP(r,l);
+	/* Things have been modified so that the initial rotate is
+	 * done outside the loop.  This required the
+	 * des_SPtrans values in sp.h to be rotated 1 bit to the right.
+	 * One perl script later and things have a 5% speed up on a sparc2.
+	 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
+	 * for pointing this out. */
+	/* clear the top bits on machines with 8byte longs */
+	/* shift left by 2 */
+	r=ROTATE(r,29)&0xffffffffL;
+	l=ROTATE(l,29)&0xffffffffL;
+
+	s=ks->ks.deslong;
+	/* I don't know if it is worth the effort of loop unrolling the
+	 * inner loop */
+	if (enc)
+		{
+#ifdef DES_UNROLL
+		D_ENCRYPT(l,r, 0); /*  1 */
+		D_ENCRYPT(r,l, 2); /*  2 */
+		D_ENCRYPT(l,r, 4); /*  3 */
+		D_ENCRYPT(r,l, 6); /*  4 */
+		D_ENCRYPT(l,r, 8); /*  5 */
+		D_ENCRYPT(r,l,10); /*  6 */
+		D_ENCRYPT(l,r,12); /*  7 */
+		D_ENCRYPT(r,l,14); /*  8 */
+		D_ENCRYPT(l,r,16); /*  9 */
+		D_ENCRYPT(r,l,18); /*  10 */
+		D_ENCRYPT(l,r,20); /*  11 */
+		D_ENCRYPT(r,l,22); /*  12 */
+		D_ENCRYPT(l,r,24); /*  13 */
+		D_ENCRYPT(r,l,26); /*  14 */
+		D_ENCRYPT(l,r,28); /*  15 */
+		D_ENCRYPT(r,l,30); /*  16 */
+#else
+		for (i=0; i<32; i+=8)
+			{
+			D_ENCRYPT(l,r,i+0); /*  1 */
+			D_ENCRYPT(r,l,i+2); /*  2 */
+			D_ENCRYPT(l,r,i+4); /*  3 */
+			D_ENCRYPT(r,l,i+6); /*  4 */
+			}
+#endif
+		}
+	else
+		{
+#ifdef DES_UNROLL
+		D_ENCRYPT(l,r,30); /* 16 */
+		D_ENCRYPT(r,l,28); /* 15 */
+		D_ENCRYPT(l,r,26); /* 14 */
+		D_ENCRYPT(r,l,24); /* 13 */
+		D_ENCRYPT(l,r,22); /* 12 */
+		D_ENCRYPT(r,l,20); /* 11 */
+		D_ENCRYPT(l,r,18); /* 10 */
+		D_ENCRYPT(r,l,16); /*  9 */
+		D_ENCRYPT(l,r,14); /*  8 */
+		D_ENCRYPT(r,l,12); /*  7 */
+		D_ENCRYPT(l,r,10); /*  6 */
+		D_ENCRYPT(r,l, 8); /*  5 */
+		D_ENCRYPT(l,r, 6); /*  4 */
+		D_ENCRYPT(r,l, 4); /*  3 */
+		D_ENCRYPT(l,r, 2); /*  2 */
+		D_ENCRYPT(r,l, 0); /*  1 */
+#else
+		for (i=30; i>0; i-=8)
+			{
+			D_ENCRYPT(l,r,i-0); /* 16 */
+			D_ENCRYPT(r,l,i-2); /* 15 */
+			D_ENCRYPT(l,r,i-4); /* 14 */
+			D_ENCRYPT(r,l,i-6); /* 13 */
+			}
+#endif
+		}
+
+	/* rotate and clear the top bits on machines with 8byte longs */
+	l=ROTATE(l,3)&0xffffffffL;
+	r=ROTATE(r,3)&0xffffffffL;
+
+	FP(r,l);
+	data[0]=l;
+	data[1]=r;
+	l=r=t=u=0;
+}
+
+void des_encrypt2(DES_LONG *data, des_key_schedule ks, int enc)
+{
+	register DES_LONG l,r,t,u;
+#ifdef DES_PTR
+	register const unsigned char *des_SP=(const unsigned char *)des_SPtrans;
+#endif
+#ifndef DES_UNROLL
+	register int i;
+#endif
+	register DES_LONG *s;
+
+	r=data[0];
+	l=data[1];
+
+	/* Things have been modified so that the initial rotate is
+	 * done outside the loop.  This required the
+	 * des_SPtrans values in sp.h to be rotated 1 bit to the right.
+	 * One perl script later and things have a 5% speed up on a sparc2.
+	 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
+	 * for pointing this out. */
+	/* clear the top bits on machines with 8byte longs */
+	r=ROTATE(r,29)&0xffffffffL;
+	l=ROTATE(l,29)&0xffffffffL;
+
+	s=ks->ks.deslong;
+	/* I don't know if it is worth the effort of loop unrolling the
+	 * inner loop */
+	if (enc)
+		{
+#ifdef DES_UNROLL
+		D_ENCRYPT(l,r, 0); /*  1 */
+		D_ENCRYPT(r,l, 2); /*  2 */
+		D_ENCRYPT(l,r, 4); /*  3 */
+		D_ENCRYPT(r,l, 6); /*  4 */
+		D_ENCRYPT(l,r, 8); /*  5 */
+		D_ENCRYPT(r,l,10); /*  6 */
+		D_ENCRYPT(l,r,12); /*  7 */
+		D_ENCRYPT(r,l,14); /*  8 */
+		D_ENCRYPT(l,r,16); /*  9 */
+		D_ENCRYPT(r,l,18); /*  10 */
+		D_ENCRYPT(l,r,20); /*  11 */
+		D_ENCRYPT(r,l,22); /*  12 */
+		D_ENCRYPT(l,r,24); /*  13 */
+		D_ENCRYPT(r,l,26); /*  14 */
+		D_ENCRYPT(l,r,28); /*  15 */
+		D_ENCRYPT(r,l,30); /*  16 */
+#else
+		for (i=0; i<32; i+=8)
+			{
+			D_ENCRYPT(l,r,i+0); /*  1 */
+			D_ENCRYPT(r,l,i+2); /*  2 */
+			D_ENCRYPT(l,r,i+4); /*  3 */
+			D_ENCRYPT(r,l,i+6); /*  4 */
+			}
+#endif
+		}
+	else
+		{
+#ifdef DES_UNROLL
+		D_ENCRYPT(l,r,30); /* 16 */
+		D_ENCRYPT(r,l,28); /* 15 */
+		D_ENCRYPT(l,r,26); /* 14 */
+		D_ENCRYPT(r,l,24); /* 13 */
+		D_ENCRYPT(l,r,22); /* 12 */
+		D_ENCRYPT(r,l,20); /* 11 */
+		D_ENCRYPT(l,r,18); /* 10 */
+		D_ENCRYPT(r,l,16); /*  9 */
+		D_ENCRYPT(l,r,14); /*  8 */
+		D_ENCRYPT(r,l,12); /*  7 */
+		D_ENCRYPT(l,r,10); /*  6 */
+		D_ENCRYPT(r,l, 8); /*  5 */
+		D_ENCRYPT(l,r, 6); /*  4 */
+		D_ENCRYPT(r,l, 4); /*  3 */
+		D_ENCRYPT(l,r, 2); /*  2 */
+		D_ENCRYPT(r,l, 0); /*  1 */
+#else
+		for (i=30; i>0; i-=8)
+			{
+			D_ENCRYPT(l,r,i-0); /* 16 */
+			D_ENCRYPT(r,l,i-2); /* 15 */
+			D_ENCRYPT(l,r,i-4); /* 14 */
+			D_ENCRYPT(r,l,i-6); /* 13 */
+			}
+#endif
+		}
+	/* rotate and clear the top bits on machines with 8byte longs */
+	data[0]=ROTATE(l,3)&0xffffffffL;
+	data[1]=ROTATE(r,3)&0xffffffffL;
+	l=r=t=u=0;
+}
+
+void des_encrypt3(DES_LONG *data, des_key_schedule ks1, des_key_schedule ks2,
+	     des_key_schedule ks3)
+{
+	register DES_LONG l,r;
+
+	l=data[0];
+	r=data[1];
+	IP(l,r);
+	data[0]=l;
+	data[1]=r;
+	des_encrypt2((DES_LONG *)data,ks1,DES_ENCRYPT);
+	des_encrypt2((DES_LONG *)data,ks2,DES_DECRYPT);
+	des_encrypt2((DES_LONG *)data,ks3,DES_ENCRYPT);
+	l=data[0];
+	r=data[1];
+	FP(r,l);
+	data[0]=l;
+	data[1]=r;
+}
+
+void des_decrypt3(DES_LONG *data, des_key_schedule ks1, des_key_schedule ks2,
+	     des_key_schedule ks3)
+{
+	register DES_LONG l,r;
+
+	l=data[0];
+	r=data[1];
+	IP(l,r);
+	data[0]=l;
+	data[1]=r;
+	des_encrypt2((DES_LONG *)data,ks3,DES_DECRYPT);
+	des_encrypt2((DES_LONG *)data,ks2,DES_ENCRYPT);
+	des_encrypt2((DES_LONG *)data,ks1,DES_DECRYPT);
+	l=data[0];
+	r=data[1];
+	FP(r,l);
+	data[0]=l;
+	data[1]=r;
+}
diff --git a/sys/crypto/des/des_locl.h b/sys/crypto/des/des_locl.h
index 82486dc..2c3cacc 100644
--- a/sys/crypto/des/des_locl.h
+++ b/sys/crypto/des/des_locl.h
@@ -1,8 +1,8 @@
 /*	$FreeBSD$	*/
-/*	$KAME: des_locl.h,v 1.6 2000/11/06 13:58:09 itojun Exp $	*/
+/*	$KAME: des_locl.h,v 1.7 2001/09/10 04:03:58 itojun Exp $	*/
 
-/* lib/des/des_locl.h */
-/* Copyright (C) 1995-1996 Eric Young (eay@mincom.oz.au)
+/* crypto/des/des_locl.h */
+/* Copyright (C) 1995-1997 Eric Young (eay@mincom.oz.au)
  * All rights reserved.
  *
  * This file is part of an SSL implementation written
@@ -47,13 +47,6 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
-/* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
- *
- * Always modify des_locl.org since des_locl.h is automatically generated from
- * it during SSLeay configuration.
- *
- * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
- */
 
 #ifndef HEADER_DES_LOCL_H
 #define HEADER_DES_LOCL_H
@@ -130,6 +123,11 @@
 
 #define	ROTATE(a,n)	(((a)>>(n))+((a)<<(32-(n))))
 
+#define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g)
+#define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
+	u=R^s[S  ]; \
+	t=R^s[S+1]
+
 /* The changes to this macro may help or hinder, depending on the
  * compiler and the achitecture.  gcc2 always seems to do well :-).
  * Inspired by Dana How <how@isl.stanford.edu>
@@ -138,49 +136,170 @@
  * bytes, probably an issue of accessing non-word aligned objects :-( */
 #ifdef DES_PTR
 
-#define D_ENCRYPT(L,R,S) { \
-	u=((R^s[S  ])<<2);	\
-	t= R^s[S+1]; \
-	t=ROTATE(t,2); \
-	L^= (\
-	*(DES_LONG *)((unsigned char *)des_SP+0x100+((t    )&0xfc))+ \
-	*(DES_LONG *)((unsigned char *)des_SP+0x300+((t>> 8)&0xfc))+ \
-	*(DES_LONG *)((unsigned char *)des_SP+0x500+((t>>16)&0xfc))+ \
-	*(DES_LONG *)((unsigned char *)des_SP+0x700+((t>>24)&0xfc))+ \
-	*(DES_LONG *)((unsigned char *)des_SP      +((u    )&0xfc))+ \
-	*(DES_LONG *)((unsigned char *)des_SP+0x200+((u>> 8)&0xfc))+ \
-	*(DES_LONG *)((unsigned char *)des_SP+0x400+((u>>16)&0xfc))+ \
-	*(DES_LONG *)((unsigned char *)des_SP+0x600+((u>>24)&0xfc))); }
+/* It recently occurred to me that 0^0^0^0^0^0^0 == 0, so there
+ * is no reason to not xor all the sub items together.  This potentially
+ * saves a register since things can be xored directly into L */
+
+#if defined(DES_RISC1) || defined(DES_RISC2)
+#ifdef DES_RISC1
+#define D_ENCRYPT(LL,R,S) { \
+        unsigned int u1,u2,u3; \
+        LOAD_DATA(R,S,u,t,E0,E1,u1); \
+        u2=(int)u>>8L; \
+        u1=(int)u&0xfc; \
+        u2&=0xfc; \
+        t=ROTATE(t,4); \
+        u>>=16L; \
+        LL^= *(const DES_LONG *)(des_SP      +u1); \
+        LL^= *(const DES_LONG *)(des_SP+0x200+u2); \
+        u3=(int)(u>>8L); \
+        u1=(int)u&0xfc; \
+        u3&=0xfc; \
+        LL^= *(const DES_LONG *)(des_SP+0x400+u1); \
+        LL^= *(const DES_LONG *)(des_SP+0x600+u3); \
+        u2=(int)t>>8L; \
+        u1=(int)t&0xfc; \
+        u2&=0xfc; \
+        t>>=16L; \
+        LL^= *(const DES_LONG *)(des_SP+0x100+u1); \
+        LL^= *(const DES_LONG *)(des_SP+0x300+u2); \
+        u3=(int)t>>8L; \
+        u1=(int)t&0xfc; \
+        u3&=0xfc; \
+        LL^= *(const DES_LONG *)(des_SP+0x500+u1); \
+        LL^= *(const DES_LONG *)(des_SP+0x700+u3); }
+#endif /* DES_RISC1 */
+#ifdef DES_RISC2
+#define D_ENCRYPT(LL,R,S) { \
+        unsigned int u1,u2,s1,s2; \
+        LOAD_DATA(R,S,u,t,E0,E1,u1); \
+        u2=(int)u>>8L; \
+        u1=(int)u&0xfc; \
+        u2&=0xfc; \
+        t=ROTATE(t,4); \
+        LL^= *(const DES_LONG *)(des_SP      +u1); \
+        LL^= *(const DES_LONG *)(des_SP+0x200+u2); \
+        s1=(int)(u>>16L); \
+        s2=(int)(u>>24L); \
+        s1&=0xfc; \
+        s2&=0xfc; \
+        LL^= *(const DES_LONG *)(des_SP+0x400+s1); \
+        LL^= *(const DES_LONG *)(des_SP+0x600+s2); \
+        u2=(int)t>>8L; \
+        u1=(int)t&0xfc; \
+        u2&=0xfc; \
+        LL^= *(const DES_LONG *)(des_SP+0x100+u1); \
+        LL^= *(const DES_LONG *)(des_SP+0x300+u2); \
+        s1=(int)(t>>16L); \
+        s2=(int)(t>>24L); \
+        s1&=0xfc; \
+        s2&=0xfc; \
+        LL^= *(const DES_LONG *)(des_SP+0x400+s1); \
+        LL^= *(const DES_LONG *)(des_SP+0x600+s2); \
+        u2=(int)t>>8L; \
+        u1=(int)t&0xfc; \
+        u2&=0xfc; \
+        LL^= *(const DES_LONG *)(des_SP+0x100+u1); \
+        LL^= *(const DES_LONG *)(des_SP+0x300+u2); \
+        s1=(int)(t>>16L); \
+        s2=(int)(t>>24L); \
+        s1&=0xfc; \
+        s2&=0xfc; \
+        LL^= *(const DES_LONG *)(des_SP+0x500+s1); \
+        LL^= *(const DES_LONG *)(des_SP+0x700+s2); }
+#endif /* DES_RISC2 */
+#else  /* DES_RISC1 || DES_RISC2 */
+#define D_ENCRYPT(LL,R,S) { \
+	LOAD_DATA_tmp(R,S,u,t,E0,E1); \
+	t=ROTATE(t,4); \
+	LL^= \
+	*(const DES_LONG *)(des_SP      +((u     )&0xfc))^ \
+	*(const DES_LONG *)(des_SP+0x200+((u>> 8L)&0xfc))^ \
+	*(const DES_LONG *)(des_SP+0x400+((u>>16L)&0xfc))^ \
+	*(const DES_LONG *)(des_SP+0x600+((u>>24L)&0xfc))^ \
+	*(const DES_LONG *)(des_SP+0x100+((t     )&0xfc))^ \
+	*(const DES_LONG *)(des_SP+0x300+((t>> 8L)&0xfc))^ \
+	*(const DES_LONG *)(des_SP+0x500+((t>>16L)&0xfc))^ \
+	*(const DES_LONG *)(des_SP+0x700+((t>>24L)&0xfc)); }
+#endif /* DES_RISC1 || DES_RISC2 */
 #else /* original version */
-#ifdef undef
-#define D_ENCRYPT(L,R,S)	\
-	U.l=R^s[S+1]; \
-	T.s[0]=((U.s[0]>>4)|(U.s[1]<<12))&0x3f3f; \
-	T.s[1]=((U.s[1]>>4)|(U.s[0]<<12))&0x3f3f; \
-	U.l=(R^s[S  ])&0x3f3f3f3fL; \
-	L^=	des_SPtrans[1][(T.c[0])]| \
-		des_SPtrans[3][(T.c[1])]| \
-		des_SPtrans[5][(T.c[2])]| \
-		des_SPtrans[7][(T.c[3])]| \
-		des_SPtrans[0][(U.c[0])]| \
-		des_SPtrans[2][(U.c[1])]| \
-		des_SPtrans[4][(U.c[2])]| \
-		des_SPtrans[6][(U.c[3])];
-#else
-#define D_ENCRYPT(Q,R,S) {\
-	u=(R^s[S  ]); \
-	t=R^s[S+1]; \
+
+#if defined(DES_RISC1) || defined(DES_RISC2)
+#ifdef DES_RISC1
+#define D_ENCRYPT(LL,R,S) {\
+	unsigned int u1,u2,u3; \
+	LOAD_DATA(R,S,u,t,E0,E1,u1); \
+	u>>=2L; \
+	t=ROTATE(t,6); \
+	u2=(int)u>>8L; \
+	u1=(int)u&0x3f; \
+	u2&=0x3f; \
+	u>>=16L; \
+	LL^=des_SPtrans[0][u1]; \
+	LL^=des_SPtrans[2][u2]; \
+	u3=(int)u>>8L; \
+	u1=(int)u&0x3f; \
+	u3&=0x3f; \
+	LL^=des_SPtrans[4][u1]; \
+	LL^=des_SPtrans[6][u3]; \
+	u2=(int)t>>8L; \
+	u1=(int)t&0x3f; \
+	u2&=0x3f; \
+	t>>=16L; \
+	LL^=des_SPtrans[1][u1]; \
+	LL^=des_SPtrans[3][u2]; \
+	u3=(int)t>>8L; \
+	u1=(int)t&0x3f; \
+	u3&=0x3f; \
+	LL^=des_SPtrans[5][u1]; \
+	LL^=des_SPtrans[7][u3]; }
+#endif /* DES_RISC1 */
+#ifdef DES_RISC2
+#define D_ENCRYPT(LL,R,S) {\
+	unsigned int u1,u2,s1,s2; \
+	LOAD_DATA(R,S,u,t,E0,E1,u1); \
+	u>>=2L; \
+	t=ROTATE(t,6); \
+	u2=(int)u>>8L; \
+	u1=(int)u&0x3f; \
+	u2&=0x3f; \
+	LL^=des_SPtrans[0][u1]; \
+	LL^=des_SPtrans[2][u2]; \
+	s1=(int)u>>16L; \
+	s2=(int)u>>24L; \
+	s1&=0x3f; \
+	s2&=0x3f; \
+	LL^=des_SPtrans[4][s1]; \
+	LL^=des_SPtrans[6][s2]; \
+	u2=(int)t>>8L; \
+	u1=(int)t&0x3f; \
+	u2&=0x3f; \
+	LL^=des_SPtrans[1][u1]; \
+	LL^=des_SPtrans[3][u2]; \
+	s1=(int)t>>16; \
+	s2=(int)t>>24L; \
+	s1&=0x3f; \
+	s2&=0x3f; \
+	LL^=des_SPtrans[5][s1]; \
+	LL^=des_SPtrans[7][s2]; }
+#endif /* DES_RISC2 */
+
+#else /* DES_RISC1 || DES_RISC2 */
+
+#define D_ENCRYPT(LL,R,S) {\
+	LOAD_DATA_tmp(R,S,u,t,E0,E1); \
 	t=ROTATE(t,4); \
-	Q^=	des_SPtrans[1][(t     )&0x3f]| \
-		des_SPtrans[3][(t>> 8L)&0x3f]| \
-		des_SPtrans[5][(t>>16L)&0x3f]| \
-		des_SPtrans[7][(t>>24L)&0x3f]| \
-		des_SPtrans[0][(u     )&0x3f]| \
-		des_SPtrans[2][(u>> 8L)&0x3f]| \
-		des_SPtrans[4][(u>>16L)&0x3f]| \
-		des_SPtrans[6][(u>>24L)&0x3f]; }
-#endif
-#endif
+	LL^=\
+        	des_SPtrans[0][(u>> 2L)&0x3f]^ \
+        	des_SPtrans[2][(u>>10L)&0x3f]^ \
+        	des_SPtrans[4][(u>>18L)&0x3f]^ \
+        	des_SPtrans[6][(u>>26L)&0x3f]^ \
+        	des_SPtrans[1][(t>> 2L)&0x3f]^ \
+        	des_SPtrans[3][(t>>10L)&0x3f]^ \
+        	des_SPtrans[5][(t>>18L)&0x3f]^ \
+        	des_SPtrans[7][(t>>26L)&0x3f]; }
+#endif /* DES_RISC1 || DES_RISC2 */
+#endif /* DES_PTR */
 
 	/* IP and FP
 	 * The problem is more of a geometric problem that random bit fiddling.
diff --git a/sys/crypto/des/des_setkey.c b/sys/crypto/des/des_setkey.c
index ff12ee4..02346d5 100644
--- a/sys/crypto/des/des_setkey.c
+++ b/sys/crypto/des/des_setkey.c
@@ -1,5 +1,5 @@
 /*	$FreeBSD$	*/
-/*	$KAME: des_setkey.c,v 1.6 2001/07/03 14:27:53 itojun Exp $	*/
+/*	$KAME: des_setkey.c,v 1.7 2001/09/10 04:03:58 itojun Exp $	*/
 
 /* crypto/des/set_key.c */
 /* Copyright (C) 1995-1996 Eric Young (eay@mincom.oz.au)
@@ -61,22 +61,18 @@
 #include <crypto/des/podd.h>
 #include <crypto/des/sk.h>
 
-static int check_parity __P((des_cblock (*)));
-
 int des_check_key=0;
 
-void des_set_odd_parity(key)
-des_cblock (*key);
-	{
+void des_set_odd_parity(des_cblock *key)
+{
 	int i;
 
 	for (i=0; i<DES_KEY_SZ; i++)
 		(*key)[i]=odd_parity[(*key)[i]];
-	}
+}
 
-static int check_parity(key)
-des_cblock (*key);
-	{
+int des_check_key_parity(des_cblock *key)
+{
 	int i;
 
 	for (i=0; i<DES_KEY_SZ; i++)
@@ -85,7 +81,7 @@ des_cblock (*key);
 			return(0);
 		}
 	return(1);
-	}
+}
 
 /* Weak and semi week keys as take from
  * %A D.W. Davies
@@ -101,8 +97,8 @@ static des_cblock weak_keys[NUM_WEAK_KEY]={
 	/* weak keys */
 	{0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01},
 	{0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE},
-	{0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F},
-	{0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0},
+	{0x1F,0x1F,0x1F,0x1F,0x0E,0x0E,0x0E,0x0E},
+	{0xE0,0xE0,0xE0,0xE0,0xF1,0xF1,0xF1,0xF1},
 	/* semi-weak keys */
 	{0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE},
 	{0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01},
@@ -117,22 +113,23 @@ static des_cblock weak_keys[NUM_WEAK_KEY]={
 	{0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE},
 	{0xFE,0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1}};
 
-int des_is_weak_key(key)
-des_cblock (*key);
-	{
+int des_is_weak_key(des_cblock *key)
+{
 	int i;
 
 	for (i=0; i<NUM_WEAK_KEY; i++)
-		/* Added == 0 to comparision, I obviously don't run
+		/* Added == 0 to comparison, I obviously don't run
 		 * this section very often :-(, thanks to
 		 * engineering@MorningStar.Com for the fix
-		 * eay 93/06/29 */
-		if (bcmp(weak_keys[i],key,sizeof(*key)) == 0) return(1);
+		 * eay 93/06/29
+		 * Another problem, I was comparing only the first 4
+		 * bytes, 97/03/18 */
+		if (memcmp(weak_keys[i],key,sizeof(des_cblock)) == 0) return(1);
 	return(0);
-	}
+}
 
 /* NOW DEFINED IN des_local.h
- * See ecb_encrypt.c for a pseudo description of these macros.
+ * See ecb_encrypt.c for a pseudo description of these macros. 
  * #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
  * 	(b)^=(t),\
  * 	(a)=((a)^((t)<<(n))))
@@ -141,49 +138,48 @@ des_cblock (*key);
 #define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
 	(a)=(a)^(t)^(t>>(16-(n))))
 
+int des_set_key(des_cblock *key, des_key_schedule schedule)
+{
+	if (des_check_key)
+	{
+		return des_set_key_checked(key, schedule);
+	}
+	else
+	{
+		des_set_key_unchecked(key, schedule);
+		return 0;
+	}
+}
+
 /* return 0 if key parity is odd (correct),
  * return -1 if key parity error,
  * return -2 if illegal weak key.
  */
-int des_set_key(key, schedule)
-des_cblock (*key);
-des_key_schedule schedule;
-	{
+int des_set_key_checked(des_cblock *key, des_key_schedule schedule)
+{
+	if (!des_check_key_parity(key))
+		return(-1);
+	if (des_is_weak_key(key))
+		return(-2);
+	des_set_key_unchecked(key, schedule);
+	return 0;
+}
+
+void des_set_key_unchecked(des_cblock *key, des_key_schedule schedule)
+{
 	static int shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
-	register DES_LONG c,d,t,s;
-	register unsigned char *in;
+	register DES_LONG c,d,t,s,t2;
+	register const unsigned char *in;
 	register DES_LONG *k;
 	register int i;
 
-	if (des_check_key)
-		{
-		if (!check_parity(key))
-			return(-1);
-
-		if (des_is_weak_key(key))
-			return(-2);
-		}
-
-	k=(DES_LONG *)schedule;
-	in=(unsigned char *)key;
+	k = &schedule->ks.deslong[0];
+	in = &(*key)[0];
 
 	c2l(in,c);
 	c2l(in,d);
 
-	/* do PC1 in 60 simple operations */
-/*	PERM_OP(d,c,t,4,0x0f0f0f0fL);
-	HPERM_OP(c,t,-2, 0xcccc0000L);
-	HPERM_OP(c,t,-1, 0xaaaa0000L);
-	HPERM_OP(c,t, 8, 0x00ff0000L);
-	HPERM_OP(c,t,-1, 0xaaaa0000L);
-	HPERM_OP(d,t,-8, 0xff000000L);
-	HPERM_OP(d,t, 8, 0x00ff0000L);
-	HPERM_OP(d,t, 2, 0x33330000L);
-	d=((d&0x00aa00aaL)<<7L)|((d&0x55005500L)>>7L)|(d&0xaa55aa55L);
-	d=(d>>8)|((c&0xf0000000L)>>4);
-	c&=0x0fffffffL; */
-
-	/* I now do it in 47 simple operations :-)
+	/* do PC1 in 47 simple operations :-)
 	 * Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)
 	 * for the inspiration. :-) */
 	PERM_OP (d,c,t,4,0x0f0f0f0fL);
@@ -197,7 +193,7 @@ des_key_schedule schedule;
 	c&=0x0fffffffL;
 
 	for (i=0; i<ITERATIONS; i++)
-		{
+	{
 		if (shifts2[i])
 			{ c=((c>>2L)|(c<<26L)); d=((d>>2L)|(d<<26L)); }
 		else
@@ -205,30 +201,32 @@ des_key_schedule schedule;
 		c&=0x0fffffffL;
 		d&=0x0fffffffL;
 		/* could be a few less shifts but I am to lazy at this
-		 * point in time to investigate */
+	 	* point in time to investigate */
 		s=	des_skb[0][ (c    )&0x3f                ]|
-			des_skb[1][((c>> 6)&0x03)|((c>> 7L)&0x3c)]|
-			des_skb[2][((c>>13)&0x0f)|((c>>14L)&0x30)]|
-			des_skb[3][((c>>20)&0x01)|((c>>21L)&0x06) |
-						  ((c>>22L)&0x38)];
+			des_skb[1][((c>> 6L)&0x03)|((c>> 7L)&0x3c)]|
+			des_skb[2][((c>>13L)&0x0f)|((c>>14L)&0x30)]|
+			des_skb[3][((c>>20L)&0x01)|((c>>21L)&0x06) |
+						  	((c>>22L)&0x38)];
 		t=	des_skb[4][ (d    )&0x3f                ]|
 			des_skb[5][((d>> 7L)&0x03)|((d>> 8L)&0x3c)]|
 			des_skb[6][ (d>>15L)&0x3f                ]|
 			des_skb[7][((d>>21L)&0x0f)|((d>>22L)&0x30)];
 
 		/* table contained 0213 4657 */
-		*(k++)=((t<<16L)|(s&0x0000ffffL))&0xffffffffL;
-		s=     ((s>>16L)|(t&0xffff0000L));
-		
-		s=(s<<4L)|(s>>28L);
-		*(k++)=s&0xffffffffL;
-		}
-	return(0);
+		t2=((t<<16L)|(s&0x0000ffffL))&0xffffffffL;
+		*(k++)=ROTATE(t2,30)&0xffffffffL;
+
+		t2=((s>>16L)|(t&0xffff0000L));
+		*(k++)=ROTATE(t2,26)&0xffffffffL;
 	}
+}
 
-int des_key_sched(key, schedule)
-des_cblock (*key);
-des_key_schedule schedule;
-	{
+int des_key_sched(des_cblock *key, des_key_schedule schedule)
+{
 	return(des_set_key(key,schedule));
-	}
+}
+
+void des_fixup_key_parity(des_cblock *key)
+{
+	des_set_odd_parity(key);
+}
diff --git a/sys/crypto/des/spr.h b/sys/crypto/des/spr.h
index 606e12b..129b827 100644
--- a/sys/crypto/des/spr.h
+++ b/sys/crypto/des/spr.h
@@ -1,23 +1,28 @@
 /*	$FreeBSD$	*/
-/*	$KAME: spr.h,v 1.3 2000/03/27 04:36:35 sumikawa Exp $	*/
+/*	$KAME: spr.h,v 1.4 2001/09/10 04:03:58 itojun Exp $	*/
 
 /* crypto/des/spr.h */
-/* Copyright (C) 1995-1996 Eric Young (eay@mincom.oz.au)
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
- * This file is part of an SSL implementation written
- * by Eric Young (eay@mincom.oz.au).
- * The implementation was written so as to conform with Netscapes SSL
- * specification.  This library and applications are
- * FREE FOR COMMERCIAL AND NON-COMMERCIAL USE
- * as long as the following conditions are aheared to.
- *
+ * 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 code is used in a product,
- * Eric Young should be given attribution as the author of the parts used.
+ * 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:
@@ -28,8 +33,14 @@
  *    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 software developed by Eric Young (eay@mincom.oz.au)
- *
+ *    "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
@@ -41,156 +52,156 @@
  * 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.]
  */
 
-static const DES_LONG des_SPtrans[8][64]={
+const DES_LONG des_SPtrans[8][64]={
 {
 /* nibble 0 */
-0x00820200L, 0x00020000L, 0x80800000L, 0x80820200L,
-0x00800000L, 0x80020200L, 0x80020000L, 0x80800000L,
-0x80020200L, 0x00820200L, 0x00820000L, 0x80000200L,
-0x80800200L, 0x00800000L, 0x00000000L, 0x80020000L,
-0x00020000L, 0x80000000L, 0x00800200L, 0x00020200L,
-0x80820200L, 0x00820000L, 0x80000200L, 0x00800200L,
-0x80000000L, 0x00000200L, 0x00020200L, 0x80820000L,
-0x00000200L, 0x80800200L, 0x80820000L, 0x00000000L,
-0x00000000L, 0x80820200L, 0x00800200L, 0x80020000L,
-0x00820200L, 0x00020000L, 0x80000200L, 0x00800200L,
-0x80820000L, 0x00000200L, 0x00020200L, 0x80800000L,
-0x80020200L, 0x80000000L, 0x80800000L, 0x00820000L,
-0x80820200L, 0x00020200L, 0x00820000L, 0x80800200L,
-0x00800000L, 0x80000200L, 0x80020000L, 0x00000000L,
-0x00020000L, 0x00800000L, 0x80800200L, 0x00820200L,
-0x80000000L, 0x80820000L, 0x00000200L, 0x80020200L,
+0x02080800L, 0x00080000L, 0x02000002L, 0x02080802L,
+0x02000000L, 0x00080802L, 0x00080002L, 0x02000002L,
+0x00080802L, 0x02080800L, 0x02080000L, 0x00000802L,
+0x02000802L, 0x02000000L, 0x00000000L, 0x00080002L,
+0x00080000L, 0x00000002L, 0x02000800L, 0x00080800L,
+0x02080802L, 0x02080000L, 0x00000802L, 0x02000800L,
+0x00000002L, 0x00000800L, 0x00080800L, 0x02080002L,
+0x00000800L, 0x02000802L, 0x02080002L, 0x00000000L,
+0x00000000L, 0x02080802L, 0x02000800L, 0x00080002L,
+0x02080800L, 0x00080000L, 0x00000802L, 0x02000800L,
+0x02080002L, 0x00000800L, 0x00080800L, 0x02000002L,
+0x00080802L, 0x00000002L, 0x02000002L, 0x02080000L,
+0x02080802L, 0x00080800L, 0x02080000L, 0x02000802L,
+0x02000000L, 0x00000802L, 0x00080002L, 0x00000000L,
+0x00080000L, 0x02000000L, 0x02000802L, 0x02080800L,
+0x00000002L, 0x02080002L, 0x00000800L, 0x00080802L,
 },{
 /* nibble 1 */
-0x10042004L, 0x00000000L, 0x00042000L, 0x10040000L,
-0x10000004L, 0x00002004L, 0x10002000L, 0x00042000L,
-0x00002000L, 0x10040004L, 0x00000004L, 0x10002000L,
-0x00040004L, 0x10042000L, 0x10040000L, 0x00000004L,
-0x00040000L, 0x10002004L, 0x10040004L, 0x00002000L,
-0x00042004L, 0x10000000L, 0x00000000L, 0x00040004L,
-0x10002004L, 0x00042004L, 0x10042000L, 0x10000004L,
-0x10000000L, 0x00040000L, 0x00002004L, 0x10042004L,
-0x00040004L, 0x10042000L, 0x10002000L, 0x00042004L,
-0x10042004L, 0x00040004L, 0x10000004L, 0x00000000L,
-0x10000000L, 0x00002004L, 0x00040000L, 0x10040004L,
-0x00002000L, 0x10000000L, 0x00042004L, 0x10002004L,
-0x10042000L, 0x00002000L, 0x00000000L, 0x10000004L,
-0x00000004L, 0x10042004L, 0x00042000L, 0x10040000L,
-0x10040004L, 0x00040000L, 0x00002004L, 0x10002000L,
-0x10002004L, 0x00000004L, 0x10040000L, 0x00042000L,
+0x40108010L, 0x00000000L, 0x00108000L, 0x40100000L,
+0x40000010L, 0x00008010L, 0x40008000L, 0x00108000L,
+0x00008000L, 0x40100010L, 0x00000010L, 0x40008000L,
+0x00100010L, 0x40108000L, 0x40100000L, 0x00000010L,
+0x00100000L, 0x40008010L, 0x40100010L, 0x00008000L,
+0x00108010L, 0x40000000L, 0x00000000L, 0x00100010L,
+0x40008010L, 0x00108010L, 0x40108000L, 0x40000010L,
+0x40000000L, 0x00100000L, 0x00008010L, 0x40108010L,
+0x00100010L, 0x40108000L, 0x40008000L, 0x00108010L,
+0x40108010L, 0x00100010L, 0x40000010L, 0x00000000L,
+0x40000000L, 0x00008010L, 0x00100000L, 0x40100010L,
+0x00008000L, 0x40000000L, 0x00108010L, 0x40008010L,
+0x40108000L, 0x00008000L, 0x00000000L, 0x40000010L,
+0x00000010L, 0x40108010L, 0x00108000L, 0x40100000L,
+0x40100010L, 0x00100000L, 0x00008010L, 0x40008000L,
+0x40008010L, 0x00000010L, 0x40100000L, 0x00108000L,
 },{
 /* nibble 2 */
-0x41000000L, 0x01010040L, 0x00000040L, 0x41000040L,
-0x40010000L, 0x01000000L, 0x41000040L, 0x00010040L,
-0x01000040L, 0x00010000L, 0x01010000L, 0x40000000L,
-0x41010040L, 0x40000040L, 0x40000000L, 0x41010000L,
-0x00000000L, 0x40010000L, 0x01010040L, 0x00000040L,
-0x40000040L, 0x41010040L, 0x00010000L, 0x41000000L,
-0x41010000L, 0x01000040L, 0x40010040L, 0x01010000L,
-0x00010040L, 0x00000000L, 0x01000000L, 0x40010040L,
-0x01010040L, 0x00000040L, 0x40000000L, 0x00010000L,
-0x40000040L, 0x40010000L, 0x01010000L, 0x41000040L,
-0x00000000L, 0x01010040L, 0x00010040L, 0x41010000L,
-0x40010000L, 0x01000000L, 0x41010040L, 0x40000000L,
-0x40010040L, 0x41000000L, 0x01000000L, 0x41010040L,
-0x00010000L, 0x01000040L, 0x41000040L, 0x00010040L,
-0x01000040L, 0x00000000L, 0x41010000L, 0x40000040L,
-0x41000000L, 0x40010040L, 0x00000040L, 0x01010000L,
+0x04000001L, 0x04040100L, 0x00000100L, 0x04000101L,
+0x00040001L, 0x04000000L, 0x04000101L, 0x00040100L,
+0x04000100L, 0x00040000L, 0x04040000L, 0x00000001L,
+0x04040101L, 0x00000101L, 0x00000001L, 0x04040001L,
+0x00000000L, 0x00040001L, 0x04040100L, 0x00000100L,
+0x00000101L, 0x04040101L, 0x00040000L, 0x04000001L,
+0x04040001L, 0x04000100L, 0x00040101L, 0x04040000L,
+0x00040100L, 0x00000000L, 0x04000000L, 0x00040101L,
+0x04040100L, 0x00000100L, 0x00000001L, 0x00040000L,
+0x00000101L, 0x00040001L, 0x04040000L, 0x04000101L,
+0x00000000L, 0x04040100L, 0x00040100L, 0x04040001L,
+0x00040001L, 0x04000000L, 0x04040101L, 0x00000001L,
+0x00040101L, 0x04000001L, 0x04000000L, 0x04040101L,
+0x00040000L, 0x04000100L, 0x04000101L, 0x00040100L,
+0x04000100L, 0x00000000L, 0x04040001L, 0x00000101L,
+0x04000001L, 0x00040101L, 0x00000100L, 0x04040000L,
 },{
 /* nibble 3 */
-0x00100402L, 0x04000400L, 0x00000002L, 0x04100402L,
-0x00000000L, 0x04100000L, 0x04000402L, 0x00100002L,
-0x04100400L, 0x04000002L, 0x04000000L, 0x00000402L,
-0x04000002L, 0x00100402L, 0x00100000L, 0x04000000L,
-0x04100002L, 0x00100400L, 0x00000400L, 0x00000002L,
-0x00100400L, 0x04000402L, 0x04100000L, 0x00000400L,
-0x00000402L, 0x00000000L, 0x00100002L, 0x04100400L,
-0x04000400L, 0x04100002L, 0x04100402L, 0x00100000L,
-0x04100002L, 0x00000402L, 0x00100000L, 0x04000002L,
-0x00100400L, 0x04000400L, 0x00000002L, 0x04100000L,
-0x04000402L, 0x00000000L, 0x00000400L, 0x00100002L,
-0x00000000L, 0x04100002L, 0x04100400L, 0x00000400L,
-0x04000000L, 0x04100402L, 0x00100402L, 0x00100000L,
-0x04100402L, 0x00000002L, 0x04000400L, 0x00100402L,
-0x00100002L, 0x00100400L, 0x04100000L, 0x04000402L,
-0x00000402L, 0x04000000L, 0x04000002L, 0x04100400L,
+0x00401008L, 0x10001000L, 0x00000008L, 0x10401008L,
+0x00000000L, 0x10400000L, 0x10001008L, 0x00400008L,
+0x10401000L, 0x10000008L, 0x10000000L, 0x00001008L,
+0x10000008L, 0x00401008L, 0x00400000L, 0x10000000L,
+0x10400008L, 0x00401000L, 0x00001000L, 0x00000008L,
+0x00401000L, 0x10001008L, 0x10400000L, 0x00001000L,
+0x00001008L, 0x00000000L, 0x00400008L, 0x10401000L,
+0x10001000L, 0x10400008L, 0x10401008L, 0x00400000L,
+0x10400008L, 0x00001008L, 0x00400000L, 0x10000008L,
+0x00401000L, 0x10001000L, 0x00000008L, 0x10400000L,
+0x10001008L, 0x00000000L, 0x00001000L, 0x00400008L,
+0x00000000L, 0x10400008L, 0x10401000L, 0x00001000L,
+0x10000000L, 0x10401008L, 0x00401008L, 0x00400000L,
+0x10401008L, 0x00000008L, 0x10001000L, 0x00401008L,
+0x00400008L, 0x00401000L, 0x10400000L, 0x10001008L,
+0x00001008L, 0x10000000L, 0x10000008L, 0x10401000L,
 },{
 /* nibble 4 */
-0x02000000L, 0x00004000L, 0x00000100L, 0x02004108L,
-0x02004008L, 0x02000100L, 0x00004108L, 0x02004000L,
-0x00004000L, 0x00000008L, 0x02000008L, 0x00004100L,
-0x02000108L, 0x02004008L, 0x02004100L, 0x00000000L,
-0x00004100L, 0x02000000L, 0x00004008L, 0x00000108L,
-0x02000100L, 0x00004108L, 0x00000000L, 0x02000008L,
-0x00000008L, 0x02000108L, 0x02004108L, 0x00004008L,
-0x02004000L, 0x00000100L, 0x00000108L, 0x02004100L,
-0x02004100L, 0x02000108L, 0x00004008L, 0x02004000L,
-0x00004000L, 0x00000008L, 0x02000008L, 0x02000100L,
-0x02000000L, 0x00004100L, 0x02004108L, 0x00000000L,
-0x00004108L, 0x02000000L, 0x00000100L, 0x00004008L,
-0x02000108L, 0x00000100L, 0x00000000L, 0x02004108L,
-0x02004008L, 0x02004100L, 0x00000108L, 0x00004000L,
-0x00004100L, 0x02004008L, 0x02000100L, 0x00000108L,
-0x00000008L, 0x00004108L, 0x02004000L, 0x02000008L,
+0x08000000L, 0x00010000L, 0x00000400L, 0x08010420L,
+0x08010020L, 0x08000400L, 0x00010420L, 0x08010000L,
+0x00010000L, 0x00000020L, 0x08000020L, 0x00010400L,
+0x08000420L, 0x08010020L, 0x08010400L, 0x00000000L,
+0x00010400L, 0x08000000L, 0x00010020L, 0x00000420L,
+0x08000400L, 0x00010420L, 0x00000000L, 0x08000020L,
+0x00000020L, 0x08000420L, 0x08010420L, 0x00010020L,
+0x08010000L, 0x00000400L, 0x00000420L, 0x08010400L,
+0x08010400L, 0x08000420L, 0x00010020L, 0x08010000L,
+0x00010000L, 0x00000020L, 0x08000020L, 0x08000400L,
+0x08000000L, 0x00010400L, 0x08010420L, 0x00000000L,
+0x00010420L, 0x08000000L, 0x00000400L, 0x00010020L,
+0x08000420L, 0x00000400L, 0x00000000L, 0x08010420L,
+0x08010020L, 0x08010400L, 0x00000420L, 0x00010000L,
+0x00010400L, 0x08010020L, 0x08000400L, 0x00000420L,
+0x00000020L, 0x00010420L, 0x08010000L, 0x08000020L,
 },{
 /* nibble 5 */
-0x20000010L, 0x00080010L, 0x00000000L, 0x20080800L,
-0x00080010L, 0x00000800L, 0x20000810L, 0x00080000L,
-0x00000810L, 0x20080810L, 0x00080800L, 0x20000000L,
-0x20000800L, 0x20000010L, 0x20080000L, 0x00080810L,
-0x00080000L, 0x20000810L, 0x20080010L, 0x00000000L,
-0x00000800L, 0x00000010L, 0x20080800L, 0x20080010L,
-0x20080810L, 0x20080000L, 0x20000000L, 0x00000810L,
-0x00000010L, 0x00080800L, 0x00080810L, 0x20000800L,
-0x00000810L, 0x20000000L, 0x20000800L, 0x00080810L,
-0x20080800L, 0x00080010L, 0x00000000L, 0x20000800L,
-0x20000000L, 0x00000800L, 0x20080010L, 0x00080000L,
-0x00080010L, 0x20080810L, 0x00080800L, 0x00000010L,
-0x20080810L, 0x00080800L, 0x00080000L, 0x20000810L,
-0x20000010L, 0x20080000L, 0x00080810L, 0x00000000L,
-0x00000800L, 0x20000010L, 0x20000810L, 0x20080800L,
-0x20080000L, 0x00000810L, 0x00000010L, 0x20080010L,
+0x80000040L, 0x00200040L, 0x00000000L, 0x80202000L,
+0x00200040L, 0x00002000L, 0x80002040L, 0x00200000L,
+0x00002040L, 0x80202040L, 0x00202000L, 0x80000000L,
+0x80002000L, 0x80000040L, 0x80200000L, 0x00202040L,
+0x00200000L, 0x80002040L, 0x80200040L, 0x00000000L,
+0x00002000L, 0x00000040L, 0x80202000L, 0x80200040L,
+0x80202040L, 0x80200000L, 0x80000000L, 0x00002040L,
+0x00000040L, 0x00202000L, 0x00202040L, 0x80002000L,
+0x00002040L, 0x80000000L, 0x80002000L, 0x00202040L,
+0x80202000L, 0x00200040L, 0x00000000L, 0x80002000L,
+0x80000000L, 0x00002000L, 0x80200040L, 0x00200000L,
+0x00200040L, 0x80202040L, 0x00202000L, 0x00000040L,
+0x80202040L, 0x00202000L, 0x00200000L, 0x80002040L,
+0x80000040L, 0x80200000L, 0x00202040L, 0x00000000L,
+0x00002000L, 0x80000040L, 0x80002040L, 0x80202000L,
+0x80200000L, 0x00002040L, 0x00000040L, 0x80200040L,
 },{
 /* nibble 6 */
-0x00001000L, 0x00000080L, 0x00400080L, 0x00400001L,
-0x00401081L, 0x00001001L, 0x00001080L, 0x00000000L,
-0x00400000L, 0x00400081L, 0x00000081L, 0x00401000L,
-0x00000001L, 0x00401080L, 0x00401000L, 0x00000081L,
-0x00400081L, 0x00001000L, 0x00001001L, 0x00401081L,
-0x00000000L, 0x00400080L, 0x00400001L, 0x00001080L,
-0x00401001L, 0x00001081L, 0x00401080L, 0x00000001L,
-0x00001081L, 0x00401001L, 0x00000080L, 0x00400000L,
-0x00001081L, 0x00401000L, 0x00401001L, 0x00000081L,
-0x00001000L, 0x00000080L, 0x00400000L, 0x00401001L,
-0x00400081L, 0x00001081L, 0x00001080L, 0x00000000L,
-0x00000080L, 0x00400001L, 0x00000001L, 0x00400080L,
-0x00000000L, 0x00400081L, 0x00400080L, 0x00001080L,
-0x00000081L, 0x00001000L, 0x00401081L, 0x00400000L,
-0x00401080L, 0x00000001L, 0x00001001L, 0x00401081L,
-0x00400001L, 0x00401080L, 0x00401000L, 0x00001001L,
+0x00004000L, 0x00000200L, 0x01000200L, 0x01000004L,
+0x01004204L, 0x00004004L, 0x00004200L, 0x00000000L,
+0x01000000L, 0x01000204L, 0x00000204L, 0x01004000L,
+0x00000004L, 0x01004200L, 0x01004000L, 0x00000204L,
+0x01000204L, 0x00004000L, 0x00004004L, 0x01004204L,
+0x00000000L, 0x01000200L, 0x01000004L, 0x00004200L,
+0x01004004L, 0x00004204L, 0x01004200L, 0x00000004L,
+0x00004204L, 0x01004004L, 0x00000200L, 0x01000000L,
+0x00004204L, 0x01004000L, 0x01004004L, 0x00000204L,
+0x00004000L, 0x00000200L, 0x01000000L, 0x01004004L,
+0x01000204L, 0x00004204L, 0x00004200L, 0x00000000L,
+0x00000200L, 0x01000004L, 0x00000004L, 0x01000200L,
+0x00000000L, 0x01000204L, 0x01000200L, 0x00004200L,
+0x00000204L, 0x00004000L, 0x01004204L, 0x01000000L,
+0x01004200L, 0x00000004L, 0x00004004L, 0x01004204L,
+0x01000004L, 0x01004200L, 0x01004000L, 0x00004004L,
 },{
 /* nibble 7 */
-0x08200020L, 0x08208000L, 0x00008020L, 0x00000000L,
-0x08008000L, 0x00200020L, 0x08200000L, 0x08208020L,
-0x00000020L, 0x08000000L, 0x00208000L, 0x00008020L,
-0x00208020L, 0x08008020L, 0x08000020L, 0x08200000L,
-0x00008000L, 0x00208020L, 0x00200020L, 0x08008000L,
-0x08208020L, 0x08000020L, 0x00000000L, 0x00208000L,
-0x08000000L, 0x00200000L, 0x08008020L, 0x08200020L,
-0x00200000L, 0x00008000L, 0x08208000L, 0x00000020L,
-0x00200000L, 0x00008000L, 0x08000020L, 0x08208020L,
-0x00008020L, 0x08000000L, 0x00000000L, 0x00208000L,
-0x08200020L, 0x08008020L, 0x08008000L, 0x00200020L,
-0x08208000L, 0x00000020L, 0x00200020L, 0x08008000L,
-0x08208020L, 0x00200000L, 0x08200000L, 0x08000020L,
-0x00208000L, 0x00008020L, 0x08008020L, 0x08200000L,
-0x00000020L, 0x08208000L, 0x00208020L, 0x00000000L,
-0x08000000L, 0x08200020L, 0x00008000L, 0x00208020L,
+0x20800080L, 0x20820000L, 0x00020080L, 0x00000000L,
+0x20020000L, 0x00800080L, 0x20800000L, 0x20820080L,
+0x00000080L, 0x20000000L, 0x00820000L, 0x00020080L,
+0x00820080L, 0x20020080L, 0x20000080L, 0x20800000L,
+0x00020000L, 0x00820080L, 0x00800080L, 0x20020000L,
+0x20820080L, 0x20000080L, 0x00000000L, 0x00820000L,
+0x20000000L, 0x00800000L, 0x20020080L, 0x20800080L,
+0x00800000L, 0x00020000L, 0x20820000L, 0x00000080L,
+0x00800000L, 0x00020000L, 0x20000080L, 0x20820080L,
+0x00020080L, 0x20000000L, 0x00000000L, 0x00820000L,
+0x20800080L, 0x20020080L, 0x20020000L, 0x00800080L,
+0x20820000L, 0x00000080L, 0x00800080L, 0x20020000L,
+0x20820080L, 0x00800000L, 0x20800000L, 0x20000080L,
+0x00820000L, 0x00020080L, 0x20020080L, 0x20800000L,
+0x00000080L, 0x20820000L, 0x00820080L, 0x00000000L,
+0x20000000L, 0x20800080L, 0x00020000L, 0x00820080L,
 }};