diff --git a/lib/libmd/Makefile b/lib/libmd/Makefile
--- a/lib/libmd/Makefile
+++ b/lib/libmd/Makefile
@@ -117,8 +117,8 @@
 .endif
 
 .if ${USE_ASM_SOURCES} != 0
-.if exists(${MACHINE_ARCH}/sha.S)
-SRCS+=	sha.S
+.if exists(${MACHINE_ARCH}/sha1block.S)
+SRCS+=	sha1block.S
 CFLAGS+= -DSHA1_ASM
 .endif
 .if exists(${MACHINE_ARCH}/rmd160.S)
@@ -135,7 +135,7 @@
 # the assembly vs C versions, and skein_block needs to be rebuilt if it changes.
 skein_block.o skein_block.pico: Makefile
 .endif
-.if exists(${MACHINE_ARCH}/sha.S) || exists(${MACHINE_ARCH}/rmd160.S) || exists(${MACHINE_ARCH}/skein_block_asm.S)
+.if exists(${MACHINE_ARCH}/rmd160.S) || exists(${MACHINE_ARCH}/skein_block_asm.S)
 ACFLAGS+= -DELF -Wa,--noexecstack
 .endif
 .if ${MACHINE_CPUARCH} == "aarch64"
diff --git a/lib/libmd/i386/sha.S b/lib/libmd/i386/sha.S
deleted file mode 100644
--- a/lib/libmd/i386/sha.S
+++ /dev/null
@@ -1,1951 +0,0 @@
-/* -*- Fundamental -*- Emacs' assembler mode hoses this file */
-#ifndef PIC
-/* Run the C pre-processor over this file with one of the following defined
- * ELF - elf object files,
- * OUT - a.out object files,
- * BSDI - BSDI style a.out object files
- * SOL - Solaris style elf
- */
-
-#define TYPE(a,b)       .type   a,b
-#define SIZE(a,b)       .size   a,b
-
-#if defined(OUT) || defined(BSDI)
-#define sha1_block_x86 _sha1_block_x86
-
-#endif
-
-#ifdef OUT
-#define OK	1
-#define ALIGN	4
-#endif
-
-#ifdef BSDI
-#define OK              1
-#define ALIGN           4
-#undef SIZE
-#undef TYPE
-#define SIZE(a,b)
-#define TYPE(a,b)
-#endif
-
-#if defined(ELF) || defined(SOL)
-#define OK              1
-#define ALIGN           4
-#endif
-
-#ifndef OK
-You need to define one of
-ELF - elf systems - linux-elf, NetBSD and DG-UX
-OUT - a.out systems - linux-a.out and FreeBSD
-SOL - solaris systems, which are elf with strange comment lines
-BSDI - a.out with a very primative version of as.
-#endif
-
-/* Let the Assembler begin :-) */
-	/* Don't even think of reading this code */
-	/* It was automatically generated by sha1-586.pl */
-	/* Which is a perl program used to generate the x86 assember for */
-	/* any of elf, a.out, BSDI,Win32, or Solaris */
-	/* eric <eay@cryptsoft.com> */
-
-	.file	"sha1-586.s"
-	.version	"01.01"
-gcc2_compiled.:
-.text
-	.p2align ALIGN
-.globl sha1_block_x86
-	TYPE(sha1_block_x86,@function)
-sha1_block_x86:
-	pushl	%esi
-	pushl	%ebp
-	movl	20(%esp),	%eax
-	movl	16(%esp),	%esi
-	addl	%esi,		%eax
-	movl	12(%esp),	%ebp
-	pushl	%ebx
-	subl	$64,		%eax
-	pushl	%edi
-	movl	4(%ebp),	%ebx
-	subl	$72,		%esp
-	movl	12(%ebp),	%edx
-	movl	16(%ebp),	%edi
-	movl	8(%ebp),	%ecx
-	movl	%eax,		68(%esp)
-	/* First we need to setup the X array */
-	movl	(%esi),		%eax
-.L000start:
-	/* First, load the words onto the stack in network byte order */
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		(%esp)
-	movl	4(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		4(%esp)
-	movl	8(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		8(%esp)
-	movl	12(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		12(%esp)
-	movl	16(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		16(%esp)
-	movl	20(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		20(%esp)
-	movl	24(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		24(%esp)
-	movl	28(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		28(%esp)
-	movl	32(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		32(%esp)
-	movl	36(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		36(%esp)
-	movl	40(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		40(%esp)
-	movl	44(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		44(%esp)
-	movl	48(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		48(%esp)
-	movl	52(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		52(%esp)
-	movl	56(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		56(%esp)
-	movl	60(%esi),	%eax
-.byte 15
-.byte 200		/* bswapl  %eax */
-	movl	%eax,		60(%esp)
-	/* We now have the X array on the stack */
-	/* starting at sp-4 */
-	movl	%esi,		64(%esp)
-
-	/* Start processing */
-	movl	(%ebp),		%eax
-	/* 00_15 0 */
-	movl	%ecx,		%esi
-	movl	%eax,		%ebp
-	xorl	%edx,		%esi
-	roll	$5,		%ebp
-	andl	%ebx,		%esi
-	addl	%edi,		%ebp
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	movl	(%esp),		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	xorl	%edx,		%esi
-	leal	1518500249(%ebp,%edi,1),%ebp
-	movl	%ebx,		%edi
-	addl	%ebp,		%esi
-	xorl	%ecx,		%edi
-	movl	%esi,		%ebp
-	andl	%eax,		%edi
-	roll	$5,		%ebp
-	addl	%edx,		%ebp
-	movl	4(%esp),	%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	xorl	%ecx,		%edi
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	leal	1518500249(%ebp,%edx,1),%ebp
-	addl	%ebp,		%edi
-	/* 00_15 2 */
-	movl	%eax,		%edx
-	movl	%edi,		%ebp
-	xorl	%ebx,		%edx
-	roll	$5,		%ebp
-	andl	%esi,		%edx
-	addl	%ecx,		%ebp
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	movl	8(%esp),	%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	xorl	%ebx,		%edx
-	leal	1518500249(%ebp,%ecx,1),%ebp
-	movl	%esi,		%ecx
-	addl	%ebp,		%edx
-	xorl	%eax,		%ecx
-	movl	%edx,		%ebp
-	andl	%edi,		%ecx
-	roll	$5,		%ebp
-	addl	%ebx,		%ebp
-	movl	12(%esp),	%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	xorl	%eax,		%ecx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	leal	1518500249(%ebp,%ebx,1),%ebp
-	addl	%ebp,		%ecx
-	/* 00_15 4 */
-	movl	%edi,		%ebx
-	movl	%ecx,		%ebp
-	xorl	%esi,		%ebx
-	roll	$5,		%ebp
-	andl	%edx,		%ebx
-	addl	%eax,		%ebp
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	movl	16(%esp),	%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	xorl	%esi,		%ebx
-	leal	1518500249(%ebp,%eax,1),%ebp
-	movl	%edx,		%eax
-	addl	%ebp,		%ebx
-	xorl	%edi,		%eax
-	movl	%ebx,		%ebp
-	andl	%ecx,		%eax
-	roll	$5,		%ebp
-	addl	%esi,		%ebp
-	movl	20(%esp),	%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	xorl	%edi,		%eax
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	leal	1518500249(%ebp,%esi,1),%ebp
-	addl	%ebp,		%eax
-	/* 00_15 6 */
-	movl	%ecx,		%esi
-	movl	%eax,		%ebp
-	xorl	%edx,		%esi
-	roll	$5,		%ebp
-	andl	%ebx,		%esi
-	addl	%edi,		%ebp
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	movl	24(%esp),	%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	xorl	%edx,		%esi
-	leal	1518500249(%ebp,%edi,1),%ebp
-	movl	%ebx,		%edi
-	addl	%ebp,		%esi
-	xorl	%ecx,		%edi
-	movl	%esi,		%ebp
-	andl	%eax,		%edi
-	roll	$5,		%ebp
-	addl	%edx,		%ebp
-	movl	28(%esp),	%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	xorl	%ecx,		%edi
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	leal	1518500249(%ebp,%edx,1),%ebp
-	addl	%ebp,		%edi
-	/* 00_15 8 */
-	movl	%eax,		%edx
-	movl	%edi,		%ebp
-	xorl	%ebx,		%edx
-	roll	$5,		%ebp
-	andl	%esi,		%edx
-	addl	%ecx,		%ebp
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	movl	32(%esp),	%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	xorl	%ebx,		%edx
-	leal	1518500249(%ebp,%ecx,1),%ebp
-	movl	%esi,		%ecx
-	addl	%ebp,		%edx
-	xorl	%eax,		%ecx
-	movl	%edx,		%ebp
-	andl	%edi,		%ecx
-	roll	$5,		%ebp
-	addl	%ebx,		%ebp
-	movl	36(%esp),	%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	xorl	%eax,		%ecx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	leal	1518500249(%ebp,%ebx,1),%ebp
-	addl	%ebp,		%ecx
-	/* 00_15 10 */
-	movl	%edi,		%ebx
-	movl	%ecx,		%ebp
-	xorl	%esi,		%ebx
-	roll	$5,		%ebp
-	andl	%edx,		%ebx
-	addl	%eax,		%ebp
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	movl	40(%esp),	%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	xorl	%esi,		%ebx
-	leal	1518500249(%ebp,%eax,1),%ebp
-	movl	%edx,		%eax
-	addl	%ebp,		%ebx
-	xorl	%edi,		%eax
-	movl	%ebx,		%ebp
-	andl	%ecx,		%eax
-	roll	$5,		%ebp
-	addl	%esi,		%ebp
-	movl	44(%esp),	%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	xorl	%edi,		%eax
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	leal	1518500249(%ebp,%esi,1),%ebp
-	addl	%ebp,		%eax
-	/* 00_15 12 */
-	movl	%ecx,		%esi
-	movl	%eax,		%ebp
-	xorl	%edx,		%esi
-	roll	$5,		%ebp
-	andl	%ebx,		%esi
-	addl	%edi,		%ebp
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	movl	48(%esp),	%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	xorl	%edx,		%esi
-	leal	1518500249(%ebp,%edi,1),%ebp
-	movl	%ebx,		%edi
-	addl	%ebp,		%esi
-	xorl	%ecx,		%edi
-	movl	%esi,		%ebp
-	andl	%eax,		%edi
-	roll	$5,		%ebp
-	addl	%edx,		%ebp
-	movl	52(%esp),	%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	xorl	%ecx,		%edi
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	leal	1518500249(%ebp,%edx,1),%ebp
-	addl	%ebp,		%edi
-	/* 00_15 14 */
-	movl	%eax,		%edx
-	movl	%edi,		%ebp
-	xorl	%ebx,		%edx
-	roll	$5,		%ebp
-	andl	%esi,		%edx
-	addl	%ecx,		%ebp
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	movl	56(%esp),	%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	xorl	%ebx,		%edx
-	leal	1518500249(%ebp,%ecx,1),%ebp
-	movl	%esi,		%ecx
-	addl	%ebp,		%edx
-	xorl	%eax,		%ecx
-	movl	%edx,		%ebp
-	andl	%edi,		%ecx
-	roll	$5,		%ebp
-	addl	%ebx,		%ebp
-	movl	60(%esp),	%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	xorl	%eax,		%ecx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	leal	1518500249(%ebp,%ebx,1),%ebp
-	addl	%ebp,		%ecx
-	/* 16_19 16 */
-	nop
-	movl	(%esp),		%ebp
-	movl	8(%esp),	%ebx
-	xorl	%ebp,		%ebx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edi,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	xorl	%esi,		%ebp
-	movl	%ebx,		(%esp)
-	andl	%edx,		%ebp
-	leal	1518500249(%ebx,%eax,1),%ebx
-	xorl	%esi,		%ebp
-	movl	%ecx,		%eax
-	addl	%ebp,		%ebx
-	roll	$5,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%eax,		%ebx
-	movl	4(%esp),	%eax
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	56(%esp),	%ebp
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	xorl	%ebp,		%eax
-.byte 209
-.byte 192		/* roll $1 %eax */
-	movl	%edx,		%ebp
-	xorl	%edi,		%ebp
-	movl	%eax,		4(%esp)
-	andl	%ecx,		%ebp
-	leal	1518500249(%eax,%esi,1),%eax
-	xorl	%edi,		%ebp
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%eax
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%eax
-	/* 16_19 18 */
-	movl	8(%esp),	%ebp
-	movl	16(%esp),	%esi
-	xorl	%ebp,		%esi
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ecx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%edx,		%ebp
-	movl	%esi,		8(%esp)
-	andl	%ebx,		%ebp
-	leal	1518500249(%esi,%edi,1),%esi
-	xorl	%edx,		%ebp
-	movl	%eax,		%edi
-	addl	%ebp,		%esi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	movl	12(%esp),	%edi
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	(%esp),		%ebp
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	xorl	%ebp,		%edi
-.byte 209
-.byte 199		/* roll $1 %edi */
-	movl	%ebx,		%ebp
-	xorl	%ecx,		%ebp
-	movl	%edi,		12(%esp)
-	andl	%eax,		%ebp
-	leal	1518500249(%edi,%edx,1),%edi
-	xorl	%ecx,		%ebp
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edi
-	/* 20_39 20 */
-	movl	16(%esp),	%edx
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	xorl	%eax,		%ebp
-	movl	%edx,		16(%esp)
-	xorl	%ebx,		%ebp
-	leal	1859775393(%edx,%ecx,1),%edx
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ebp,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ecx,		%edx
-	/* 20_39 21 */
-	movl	20(%esp),	%ecx
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	%edi,		%ebp
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	xorl	%esi,		%ebp
-	movl	%ecx,		20(%esp)
-	xorl	%eax,		%ebp
-	leal	1859775393(%ecx,%ebx,1),%ecx
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ecx
-	/* 20_39 22 */
-	movl	24(%esp),	%ebx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	xorl	%edi,		%ebp
-	movl	%ebx,		24(%esp)
-	xorl	%esi,		%ebp
-	leal	1859775393(%ebx,%eax,1),%ebx
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%ebp,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%eax,		%ebx
-	/* 20_39 23 */
-	movl	28(%esp),	%eax
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	%ecx,		%ebp
-.byte 209
-.byte 192		/* roll $1 %eax */
-	xorl	%edx,		%ebp
-	movl	%eax,		28(%esp)
-	xorl	%edi,		%ebp
-	leal	1859775393(%eax,%esi,1),%eax
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%eax
-	/* 20_39 24 */
-	movl	32(%esp),	%esi
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%esi
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%ecx,		%ebp
-	movl	%esi,		32(%esp)
-	xorl	%edx,		%ebp
-	leal	1859775393(%esi,%edi,1),%esi
-	movl	%eax,		%edi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%ebp,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	/* 20_39 25 */
-	movl	36(%esp),	%edi
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	%eax,		%ebp
-.byte 209
-.byte 199		/* roll $1 %edi */
-	xorl	%ebx,		%ebp
-	movl	%edi,		36(%esp)
-	xorl	%ecx,		%ebp
-	leal	1859775393(%edi,%edx,1),%edi
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-	/* 20_39 26 */
-	movl	40(%esp),	%edx
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	xorl	%eax,		%ebp
-	movl	%edx,		40(%esp)
-	xorl	%ebx,		%ebp
-	leal	1859775393(%edx,%ecx,1),%edx
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ebp,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ecx,		%edx
-	/* 20_39 27 */
-	movl	44(%esp),	%ecx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	%edi,		%ebp
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	xorl	%esi,		%ebp
-	movl	%ecx,		44(%esp)
-	xorl	%eax,		%ebp
-	leal	1859775393(%ecx,%ebx,1),%ecx
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ecx
-	/* 20_39 28 */
-	movl	48(%esp),	%ebx
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	xorl	%edi,		%ebp
-	movl	%ebx,		48(%esp)
-	xorl	%esi,		%ebp
-	leal	1859775393(%ebx,%eax,1),%ebx
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%ebp,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%eax,		%ebx
-	/* 20_39 29 */
-	movl	52(%esp),	%eax
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	%ecx,		%ebp
-.byte 209
-.byte 192		/* roll $1 %eax */
-	xorl	%edx,		%ebp
-	movl	%eax,		52(%esp)
-	xorl	%edi,		%ebp
-	leal	1859775393(%eax,%esi,1),%eax
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%eax
-	/* 20_39 30 */
-	movl	56(%esp),	%esi
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%esi
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%ecx,		%ebp
-	movl	%esi,		56(%esp)
-	xorl	%edx,		%ebp
-	leal	1859775393(%esi,%edi,1),%esi
-	movl	%eax,		%edi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%ebp,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	/* 20_39 31 */
-	movl	60(%esp),	%edi
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	%eax,		%ebp
-.byte 209
-.byte 199		/* roll $1 %edi */
-	xorl	%ebx,		%ebp
-	movl	%edi,		60(%esp)
-	xorl	%ecx,		%ebp
-	leal	1859775393(%edi,%edx,1),%edi
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-	/* 20_39 32 */
-	movl	(%esp),		%edx
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	xorl	%eax,		%ebp
-	movl	%edx,		(%esp)
-	xorl	%ebx,		%ebp
-	leal	1859775393(%edx,%ecx,1),%edx
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ebp,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ecx,		%edx
-	/* 20_39 33 */
-	movl	4(%esp),	%ecx
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	%edi,		%ebp
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	xorl	%esi,		%ebp
-	movl	%ecx,		4(%esp)
-	xorl	%eax,		%ebp
-	leal	1859775393(%ecx,%ebx,1),%ecx
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ecx
-	/* 20_39 34 */
-	movl	8(%esp),	%ebx
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	xorl	%edi,		%ebp
-	movl	%ebx,		8(%esp)
-	xorl	%esi,		%ebp
-	leal	1859775393(%ebx,%eax,1),%ebx
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%ebp,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%eax,		%ebx
-	/* 20_39 35 */
-	movl	12(%esp),	%eax
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%eax
-	movl	%ecx,		%ebp
-.byte 209
-.byte 192		/* roll $1 %eax */
-	xorl	%edx,		%ebp
-	movl	%eax,		12(%esp)
-	xorl	%edi,		%ebp
-	leal	1859775393(%eax,%esi,1),%eax
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%eax
-	/* 20_39 36 */
-	movl	16(%esp),	%esi
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%ecx,		%ebp
-	movl	%esi,		16(%esp)
-	xorl	%edx,		%ebp
-	leal	1859775393(%esi,%edi,1),%esi
-	movl	%eax,		%edi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%ebp,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	/* 20_39 37 */
-	movl	20(%esp),	%edi
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	%eax,		%ebp
-.byte 209
-.byte 199		/* roll $1 %edi */
-	xorl	%ebx,		%ebp
-	movl	%edi,		20(%esp)
-	xorl	%ecx,		%ebp
-	leal	1859775393(%edi,%edx,1),%edi
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-	/* 20_39 38 */
-	movl	24(%esp),	%edx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	xorl	%eax,		%ebp
-	movl	%edx,		24(%esp)
-	xorl	%ebx,		%ebp
-	leal	1859775393(%edx,%ecx,1),%edx
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ebp,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ecx,		%edx
-	/* 20_39 39 */
-	movl	28(%esp),	%ecx
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	%edi,		%ebp
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	xorl	%esi,		%ebp
-	movl	%ecx,		28(%esp)
-	xorl	%eax,		%ebp
-	leal	1859775393(%ecx,%ebx,1),%ecx
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ecx
-	/* 40_59 40 */
-	movl	32(%esp),	%ebx
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%ebx
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	orl	%edi,		%ebp
-	movl	%ebx,		32(%esp)
-	andl	%esi,		%ebp
-	leal	2400959708(%ebx,%eax,1),%ebx
-	movl	%edx,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	andl	%edi,		%eax
-	orl	%eax,		%ebp
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-	addl	%eax,		%ebp
-	movl	36(%esp),	%eax
-	addl	%ebp,		%ebx
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	24(%esp),	%ebp
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	xorl	%ebp,		%eax
-.byte 209
-.byte 192		/* roll $1 %eax */
-	movl	%ecx,		%ebp
-	movl	%eax,		36(%esp)
-	orl	%edx,		%ebp
-	leal	2400959708(%eax,%esi,1),%eax
-	movl	%ecx,		%esi
-	andl	%edi,		%ebp
-	andl	%edx,		%esi
-	orl	%esi,		%ebp
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%ebp
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%eax
-	/* 40_59 41 */
-	/* 40_59 42 */
-	movl	40(%esp),	%esi
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	orl	%ecx,		%ebp
-	movl	%esi,		40(%esp)
-	andl	%edx,		%ebp
-	leal	2400959708(%esi,%edi,1),%esi
-	movl	%ebx,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	andl	%ecx,		%edi
-	orl	%edi,		%ebp
-	movl	%eax,		%edi
-	roll	$5,		%edi
-	addl	%edi,		%ebp
-	movl	44(%esp),	%edi
-	addl	%ebp,		%esi
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	32(%esp),	%ebp
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	xorl	%ebp,		%edi
-.byte 209
-.byte 199		/* roll $1 %edi */
-	movl	%eax,		%ebp
-	movl	%edi,		44(%esp)
-	orl	%ebx,		%ebp
-	leal	2400959708(%edi,%edx,1),%edi
-	movl	%eax,		%edx
-	andl	%ecx,		%ebp
-	andl	%ebx,		%edx
-	orl	%edx,		%ebp
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%ebp
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edi
-	/* 40_59 43 */
-	/* 40_59 44 */
-	movl	48(%esp),	%edx
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	orl	%eax,		%ebp
-	movl	%edx,		48(%esp)
-	andl	%ebx,		%ebp
-	leal	2400959708(%edx,%ecx,1),%edx
-	movl	%esi,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	andl	%eax,		%ecx
-	orl	%ecx,		%ebp
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-	addl	%ecx,		%ebp
-	movl	52(%esp),	%ecx
-	addl	%ebp,		%edx
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	40(%esp),	%ebp
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	xorl	%ebp,		%ecx
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	movl	%edi,		%ebp
-	movl	%ecx,		52(%esp)
-	orl	%esi,		%ebp
-	leal	2400959708(%ecx,%ebx,1),%ecx
-	movl	%edi,		%ebx
-	andl	%eax,		%ebp
-	andl	%esi,		%ebx
-	orl	%ebx,		%ebp
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ebp
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ecx
-	/* 40_59 45 */
-	/* 40_59 46 */
-	movl	56(%esp),	%ebx
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%ebx
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	orl	%edi,		%ebp
-	movl	%ebx,		56(%esp)
-	andl	%esi,		%ebp
-	leal	2400959708(%ebx,%eax,1),%ebx
-	movl	%edx,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	andl	%edi,		%eax
-	orl	%eax,		%ebp
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-	addl	%eax,		%ebp
-	movl	60(%esp),	%eax
-	addl	%ebp,		%ebx
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	48(%esp),	%ebp
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	xorl	%ebp,		%eax
-.byte 209
-.byte 192		/* roll $1 %eax */
-	movl	%ecx,		%ebp
-	movl	%eax,		60(%esp)
-	orl	%edx,		%ebp
-	leal	2400959708(%eax,%esi,1),%eax
-	movl	%ecx,		%esi
-	andl	%edi,		%ebp
-	andl	%edx,		%esi
-	orl	%esi,		%ebp
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%ebp
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%eax
-	/* 40_59 47 */
-	/* 40_59 48 */
-	movl	(%esp),		%esi
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	orl	%ecx,		%ebp
-	movl	%esi,		(%esp)
-	andl	%edx,		%ebp
-	leal	2400959708(%esi,%edi,1),%esi
-	movl	%ebx,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	andl	%ecx,		%edi
-	orl	%edi,		%ebp
-	movl	%eax,		%edi
-	roll	$5,		%edi
-	addl	%edi,		%ebp
-	movl	4(%esp),	%edi
-	addl	%ebp,		%esi
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	56(%esp),	%ebp
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	xorl	%ebp,		%edi
-.byte 209
-.byte 199		/* roll $1 %edi */
-	movl	%eax,		%ebp
-	movl	%edi,		4(%esp)
-	orl	%ebx,		%ebp
-	leal	2400959708(%edi,%edx,1),%edi
-	movl	%eax,		%edx
-	andl	%ecx,		%ebp
-	andl	%ebx,		%edx
-	orl	%edx,		%ebp
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%ebp
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edi
-	/* 40_59 49 */
-	/* 40_59 50 */
-	movl	8(%esp),	%edx
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	orl	%eax,		%ebp
-	movl	%edx,		8(%esp)
-	andl	%ebx,		%ebp
-	leal	2400959708(%edx,%ecx,1),%edx
-	movl	%esi,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	andl	%eax,		%ecx
-	orl	%ecx,		%ebp
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-	addl	%ecx,		%ebp
-	movl	12(%esp),	%ecx
-	addl	%ebp,		%edx
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	(%esp),		%ebp
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	xorl	%ebp,		%ecx
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	movl	%edi,		%ebp
-	movl	%ecx,		12(%esp)
-	orl	%esi,		%ebp
-	leal	2400959708(%ecx,%ebx,1),%ecx
-	movl	%edi,		%ebx
-	andl	%eax,		%ebp
-	andl	%esi,		%ebx
-	orl	%ebx,		%ebp
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ebp
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ecx
-	/* 40_59 51 */
-	/* 40_59 52 */
-	movl	16(%esp),	%ebx
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	orl	%edi,		%ebp
-	movl	%ebx,		16(%esp)
-	andl	%esi,		%ebp
-	leal	2400959708(%ebx,%eax,1),%ebx
-	movl	%edx,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	andl	%edi,		%eax
-	orl	%eax,		%ebp
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-	addl	%eax,		%ebp
-	movl	20(%esp),	%eax
-	addl	%ebp,		%ebx
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	8(%esp),	%ebp
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	xorl	%ebp,		%eax
-.byte 209
-.byte 192		/* roll $1 %eax */
-	movl	%ecx,		%ebp
-	movl	%eax,		20(%esp)
-	orl	%edx,		%ebp
-	leal	2400959708(%eax,%esi,1),%eax
-	movl	%ecx,		%esi
-	andl	%edi,		%ebp
-	andl	%edx,		%esi
-	orl	%esi,		%ebp
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%ebp
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%eax
-	/* 40_59 53 */
-	/* 40_59 54 */
-	movl	24(%esp),	%esi
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	orl	%ecx,		%ebp
-	movl	%esi,		24(%esp)
-	andl	%edx,		%ebp
-	leal	2400959708(%esi,%edi,1),%esi
-	movl	%ebx,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	andl	%ecx,		%edi
-	orl	%edi,		%ebp
-	movl	%eax,		%edi
-	roll	$5,		%edi
-	addl	%edi,		%ebp
-	movl	28(%esp),	%edi
-	addl	%ebp,		%esi
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	16(%esp),	%ebp
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	xorl	%ebp,		%edi
-.byte 209
-.byte 199		/* roll $1 %edi */
-	movl	%eax,		%ebp
-	movl	%edi,		28(%esp)
-	orl	%ebx,		%ebp
-	leal	2400959708(%edi,%edx,1),%edi
-	movl	%eax,		%edx
-	andl	%ecx,		%ebp
-	andl	%ebx,		%edx
-	orl	%edx,		%ebp
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%ebp
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edi
-	/* 40_59 55 */
-	/* 40_59 56 */
-	movl	32(%esp),	%edx
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%edx
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	orl	%eax,		%ebp
-	movl	%edx,		32(%esp)
-	andl	%ebx,		%ebp
-	leal	2400959708(%edx,%ecx,1),%edx
-	movl	%esi,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	andl	%eax,		%ecx
-	orl	%ecx,		%ebp
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-	addl	%ecx,		%ebp
-	movl	36(%esp),	%ecx
-	addl	%ebp,		%edx
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	24(%esp),	%ebp
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	xorl	%ebp,		%ecx
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	movl	%edi,		%ebp
-	movl	%ecx,		36(%esp)
-	orl	%esi,		%ebp
-	leal	2400959708(%ecx,%ebx,1),%ecx
-	movl	%edi,		%ebx
-	andl	%eax,		%ebp
-	andl	%esi,		%ebx
-	orl	%ebx,		%ebp
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ebp
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ecx
-	/* 40_59 57 */
-	/* 40_59 58 */
-	movl	40(%esp),	%ebx
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	orl	%edi,		%ebp
-	movl	%ebx,		40(%esp)
-	andl	%esi,		%ebp
-	leal	2400959708(%ebx,%eax,1),%ebx
-	movl	%edx,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	andl	%edi,		%eax
-	orl	%eax,		%ebp
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-	addl	%eax,		%ebp
-	movl	44(%esp),	%eax
-	addl	%ebp,		%ebx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	32(%esp),	%ebp
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	xorl	%ebp,		%eax
-.byte 209
-.byte 192		/* roll $1 %eax */
-	movl	%ecx,		%ebp
-	movl	%eax,		44(%esp)
-	orl	%edx,		%ebp
-	leal	2400959708(%eax,%esi,1),%eax
-	movl	%ecx,		%esi
-	andl	%edi,		%ebp
-	andl	%edx,		%esi
-	orl	%esi,		%ebp
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%ebp
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%eax
-	/* 40_59 59 */
-	/* 20_39 60 */
-	movl	48(%esp),	%esi
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%ecx,		%ebp
-	movl	%esi,		48(%esp)
-	xorl	%edx,		%ebp
-	leal	3395469782(%esi,%edi,1),%esi
-	movl	%eax,		%edi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%ebp,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	/* 20_39 61 */
-	movl	52(%esp),	%edi
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	%eax,		%ebp
-.byte 209
-.byte 199		/* roll $1 %edi */
-	xorl	%ebx,		%ebp
-	movl	%edi,		52(%esp)
-	xorl	%ecx,		%ebp
-	leal	3395469782(%edi,%edx,1),%edi
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-	/* 20_39 62 */
-	movl	56(%esp),	%edx
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%edx
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	xorl	%eax,		%ebp
-	movl	%edx,		56(%esp)
-	xorl	%ebx,		%ebp
-	leal	3395469782(%edx,%ecx,1),%edx
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ebp,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ecx,		%edx
-	/* 20_39 63 */
-	movl	60(%esp),	%ecx
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	%edi,		%ebp
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	xorl	%esi,		%ebp
-	movl	%ecx,		60(%esp)
-	xorl	%eax,		%ebp
-	leal	3395469782(%ecx,%ebx,1),%ecx
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ecx
-	/* 20_39 64 */
-	movl	(%esp),		%ebx
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	xorl	%edi,		%ebp
-	movl	%ebx,		(%esp)
-	xorl	%esi,		%ebp
-	leal	3395469782(%ebx,%eax,1),%ebx
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%ebp,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%eax,		%ebx
-	/* 20_39 65 */
-	movl	4(%esp),	%eax
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	%ecx,		%ebp
-.byte 209
-.byte 192		/* roll $1 %eax */
-	xorl	%edx,		%ebp
-	movl	%eax,		4(%esp)
-	xorl	%edi,		%ebp
-	leal	3395469782(%eax,%esi,1),%eax
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%eax
-	/* 20_39 66 */
-	movl	8(%esp),	%esi
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%ecx,		%ebp
-	movl	%esi,		8(%esp)
-	xorl	%edx,		%ebp
-	leal	3395469782(%esi,%edi,1),%esi
-	movl	%eax,		%edi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%ebp,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	/* 20_39 67 */
-	movl	12(%esp),	%edi
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%edi
-	movl	%eax,		%ebp
-.byte 209
-.byte 199		/* roll $1 %edi */
-	xorl	%ebx,		%ebp
-	movl	%edi,		12(%esp)
-	xorl	%ecx,		%ebp
-	leal	3395469782(%edi,%edx,1),%edi
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-	/* 20_39 68 */
-	movl	16(%esp),	%edx
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	xorl	%eax,		%ebp
-	movl	%edx,		16(%esp)
-	xorl	%ebx,		%ebp
-	leal	3395469782(%edx,%ecx,1),%edx
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ebp,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ecx,		%edx
-	/* 20_39 69 */
-	movl	20(%esp),	%ecx
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	%edi,		%ebp
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	xorl	%esi,		%ebp
-	movl	%ecx,		20(%esp)
-	xorl	%eax,		%ebp
-	leal	3395469782(%ecx,%ebx,1),%ecx
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ecx
-	/* 20_39 70 */
-	movl	24(%esp),	%ebx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	xorl	%edi,		%ebp
-	movl	%ebx,		24(%esp)
-	xorl	%esi,		%ebp
-	leal	3395469782(%ebx,%eax,1),%ebx
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%ebp,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%eax,		%ebx
-	/* 20_39 71 */
-	movl	28(%esp),	%eax
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	%ecx,		%ebp
-.byte 209
-.byte 192		/* roll $1 %eax */
-	xorl	%edx,		%ebp
-	movl	%eax,		28(%esp)
-	xorl	%edi,		%ebp
-	leal	3395469782(%eax,%esi,1),%eax
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%eax
-	/* 20_39 72 */
-	movl	32(%esp),	%esi
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%esi
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%ecx,		%ebp
-	movl	%esi,		32(%esp)
-	xorl	%edx,		%ebp
-	leal	3395469782(%esi,%edi,1),%esi
-	movl	%eax,		%edi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%ebp,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	/* 20_39 73 */
-	movl	36(%esp),	%edi
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	%eax,		%ebp
-.byte 209
-.byte 199		/* roll $1 %edi */
-	xorl	%ebx,		%ebp
-	movl	%edi,		36(%esp)
-	xorl	%ecx,		%ebp
-	leal	3395469782(%edi,%edx,1),%edi
-	movl	%esi,		%edx
-	roll	$5,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%ebp,		%edx
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-	/* 20_39 74 */
-	movl	40(%esp),	%edx
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	8(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%edx
-	movl	%esi,		%ebp
-.byte 209
-.byte 194		/* roll $1 %edx */
-	xorl	%eax,		%ebp
-	movl	%edx,		40(%esp)
-	xorl	%ebx,		%ebp
-	leal	3395469782(%edx,%ecx,1),%edx
-	movl	%edi,		%ecx
-	roll	$5,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ebp,		%ecx
-.byte 209
-.byte 206		/* rorl $1 %esi */
-	addl	%ecx,		%edx
-	/* 20_39 75 */
-	movl	44(%esp),	%ecx
-	movl	52(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	12(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	32(%esp),	%ebp
-	xorl	%ebp,		%ecx
-	movl	%edi,		%ebp
-.byte 209
-.byte 193		/* roll $1 %ecx */
-	xorl	%esi,		%ebp
-	movl	%ecx,		44(%esp)
-	xorl	%eax,		%ebp
-	leal	3395469782(%ecx,%ebx,1),%ecx
-	movl	%edx,		%ebx
-	roll	$5,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebp,		%ebx
-.byte 209
-.byte 207		/* rorl $1 %edi */
-	addl	%ebx,		%ecx
-	/* 20_39 76 */
-	movl	48(%esp),	%ebx
-	movl	56(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	16(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	36(%esp),	%ebp
-	xorl	%ebp,		%ebx
-	movl	%edx,		%ebp
-.byte 209
-.byte 195		/* roll $1 %ebx */
-	xorl	%edi,		%ebp
-	movl	%ebx,		48(%esp)
-	xorl	%esi,		%ebp
-	leal	3395469782(%ebx,%eax,1),%ebx
-	movl	%ecx,		%eax
-	roll	$5,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%ebp,		%eax
-.byte 209
-.byte 202		/* rorl $1 %edx */
-	addl	%eax,		%ebx
-	/* 20_39 77 */
-	movl	52(%esp),	%eax
-	movl	60(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	20(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	40(%esp),	%ebp
-	xorl	%ebp,		%eax
-	movl	%ecx,		%ebp
-.byte 209
-.byte 192		/* roll $1 %eax */
-	xorl	%edx,		%ebp
-	movl	%eax,		52(%esp)
-	xorl	%edi,		%ebp
-	leal	3395469782(%eax,%esi,1),%eax
-	movl	%ebx,		%esi
-	roll	$5,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%ebp,		%esi
-.byte 209
-.byte 201		/* rorl $1 %ecx */
-	addl	%esi,		%eax
-	/* 20_39 78 */
-	movl	56(%esp),	%esi
-	movl	(%esp),		%ebp
-	xorl	%ebp,		%esi
-	movl	24(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	44(%esp),	%ebp
-	xorl	%ebp,		%esi
-	movl	%ebx,		%ebp
-.byte 209
-.byte 198		/* roll $1 %esi */
-	xorl	%ecx,		%ebp
-	movl	%esi,		56(%esp)
-	xorl	%edx,		%ebp
-	leal	3395469782(%esi,%edi,1),%esi
-	movl	%eax,		%edi
-	roll	$5,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%ebp,		%edi
-.byte 209
-.byte 203		/* rorl $1 %ebx */
-	addl	%edi,		%esi
-	/* 20_39 79 */
-	movl	60(%esp),	%edi
-	movl	4(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	28(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	48(%esp),	%ebp
-	xorl	%ebp,		%edi
-	movl	%eax,		%ebp
-.byte 209
-.byte 199		/* roll $1 %edi */
-	xorl	%ebx,		%ebp
-	movl	%edi,		60(%esp)
-	xorl	%ecx,		%ebp
-	leal	3395469782(%edi,%edx,1),%edi
-	movl	%esi,		%edx
-	roll	$5,		%edx
-	addl	%ebp,		%edx
-	movl	92(%esp),	%ebp
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	addl	%edx,		%edi
-.byte 209
-.byte 200		/* rorl $1 %eax */
-	/* End processing */
-
-	movl	12(%ebp),	%edx
-	addl	%ebx,		%edx
-	movl	4(%ebp),	%ebx
-	addl	%esi,		%ebx
-	movl	%eax,		%esi
-	movl	(%ebp),		%eax
-	movl	%edx,		12(%ebp)
-	addl	%edi,		%eax
-	movl	16(%ebp),	%edi
-	addl	%ecx,		%edi
-	movl	8(%ebp),	%ecx
-	addl	%esi,		%ecx
-	movl	%eax,		(%ebp)
-	movl	64(%esp),	%esi
-	movl	%ecx,		8(%ebp)
-	addl	$64,		%esi
-	movl	68(%esp),	%eax
-	movl	%edi,		16(%ebp)
-	cmpl	%esi,		%eax
-	movl	%ebx,		4(%ebp)
-	jb	.L001end
-	movl	(%esi),		%eax
-	jmp	.L000start
-.L001end:
-	addl	$72,		%esp
-	popl	%edi
-	popl	%ebx
-	popl	%ebp
-	popl	%esi
-	ret
-.sha1_block_x86_end:
-	SIZE(sha1_block_x86,.sha1_block_x86_end-sha1_block_x86)
-.ident	"desasm.pl"
-#endif
diff --git a/lib/libmd/sha1c.c b/lib/libmd/sha1c.c
--- a/lib/libmd/sha1c.c
+++ b/lib/libmd/sha1c.c
@@ -1,476 +1,244 @@
-/* crypto/sha/sha1dgst.c */
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
+/*-
+ * Copyright (c) 2009 The Go Authors. All rights reserved.
+ * Copyright (c) 2024 Robert Clausecker <fuz@freebsd.org>
+ *
+ * Adapted from Go's crypto/sha1/sha1.go.
  *
- * 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 routines 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.]
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *   * 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.
+ *   * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER 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.
  */
 
-#include <sys/types.h>
-
-#include <stdio.h>
+#include <assert.h>
+#include <sha.h>
+#include <stdint.h>
 #include <string.h>
+#include <strings.h>
+#include <sys/endian.h>
 
-#if 0
-#include <machine/ansi.h>	/* we use the __ variants of bit-sized types */
+#ifdef SHA1_ASM
+extern void	sha1_block(SHA1_CTX *, const void *, size_t);
+#else
+static void	sha1_block(SHA1_CTX *, const void *, size_t);
 #endif
-#include <machine/endian.h>
 
-#undef  SHA_0
-#define SHA_1
-#include "sha.h"
-#include "sha_locl.h"
+#define INIT0 0x67452301
+#define INIT1 0xEFCDAB89
+#define INIT2 0x98BADCFE
+#define INIT3 0x10325476
+#define INIT4 0xC3D2E1F0
 
-/*
- * The assembly-language code is not position-independent, so don't
- * try to use it in a shared library.
- */
-#ifdef PIC
-#undef SHA1_ASM
-#endif
+#define K0 0x5A827999
+#define K1 0x6ED9EBA1
+#define K2 0x8F1BBCDC
+#define K3 0xCA62C1D6
 
-static char *SHA1_version="SHA1 part of SSLeay 0.9.0b 11-Oct-1998";
+void
+SHA1_Init(SHA1_CTX *c)
+{
+	c->h0 = INIT0;
+	c->h1 = INIT1;
+	c->h2 = INIT2;
+	c->h3 = INIT3;
+	c->h4 = INIT4;
+	c->Nl = 0;
+	c->Nh = 0;
+	c->num = 0;
+}
 
-/* Implemented from SHA-1 document - The Secure Hash Algorithm
- */
+void
+SHA1_Update(SHA1_CTX *c, const void *data, size_t len)
+{
+	uint64_t nn;
+	const char *p = data;
 
-#define INIT_DATA_h0 (unsigned long)0x67452301L
-#define INIT_DATA_h1 (unsigned long)0xefcdab89L
-#define INIT_DATA_h2 (unsigned long)0x98badcfeL
-#define INIT_DATA_h3 (unsigned long)0x10325476L
-#define INIT_DATA_h4 (unsigned long)0xc3d2e1f0L
-
-#define K_00_19	0x5a827999L
-#define K_20_39 0x6ed9eba1L
-#define K_40_59 0x8f1bbcdcL
-#define K_60_79 0xca62c1d6L
-
-#ifndef NOPROTO
-#  ifdef SHA1_ASM
-     void sha1_block_x86(SHA_CTX *c, const u_int32_t *p, int num);
-#    define sha1_block sha1_block_x86
-#  else
-     void sha1_block(SHA_CTX *c, const u_int32_t *p, int num);
-#  endif
-#else
-#  ifdef SHA1_ASM
-     void sha1_block_x86();
-#    define sha1_block sha1_block_x86
-#  else
-     void sha1_block();
-#  endif
-#endif
+	nn = (uint64_t)c->Nl | (uint64_t)c->Nh << 32;
+	nn += len;
+	c->Nl = (uint32_t)nn;
+	c->Nh = (uint32_t)(nn >> 32);
 
+	if (c->num > 0) {
+		size_t n = SHA_CBLOCK - c->num;
 
-#if BYTE_ORDER == LITTLE_ENDIAN && defined(SHA1_ASM)
-#  define	M_c2nl 		c2l
-#  define	M_p_c2nl 	p_c2l
-#  define	M_c2nl_p	c2l_p
-#  define	M_p_c2nl_p	p_c2l_p
-#  define	M_nl2c		l2c
-#else
-#  define	M_c2nl 		c2nl
-#  define	M_p_c2nl	p_c2nl
-#  define	M_c2nl_p	c2nl_p
-#  define	M_p_c2nl_p	p_c2nl_p
-#  define	M_nl2c		nl2c
-#endif
+		if (n > len)
+			n = len;
+
+		memcpy((char *)c->data + c->num, p, n);
+		c->num += n;
+		if (c->num == SHA_CBLOCK) {
+			sha1_block(c, (void *)c->data, SHA_CBLOCK);
+			c->num = 0;
+		}
+
+		p += n;
+		len -= n;
+	}
+
+	if (len >= SHA_CBLOCK) {
+		size_t n = len & ~(size_t)(SHA_CBLOCK - 1);
+
+		sha1_block(c, p, n);
+		p += n;
+		len -= n;
+	}
 
-void SHA1_Init(SHA_CTX *c)
-	{
-	c->h0=INIT_DATA_h0;
-	c->h1=INIT_DATA_h1;
-	c->h2=INIT_DATA_h2;
-	c->h3=INIT_DATA_h3;
-	c->h4=INIT_DATA_h4;
-	c->Nl=0;
-	c->Nh=0;
-	c->num=0;
+	if (len > 0) {
+		memcpy(c->data, p, len);
+		c->num = len;
 	}
+}
 
 void
-SHA1_Update(SHA_CTX *c, const void *in, size_t len)
+SHA1_Final(unsigned char *md, SHA1_CTX *c)
 {
-	u_int32_t *p;
-	int ew,ec,sw,sc;
-	u_int32_t l;
-	const unsigned char *data = in;
-
-	if (len == 0) return;
-
-	l=(c->Nl+(len<<3))&0xffffffffL;
-	if (l < c->Nl) /* overflow */
-		c->Nh++;
-	c->Nh+=(len>>29);
-	c->Nl=l;
-
-	if (c->num != 0)
-		{
-		p=c->data;
-		sw=c->num>>2;
-		sc=c->num&0x03;
-
-		if ((c->num+len) >= SHA_CBLOCK)
-			{
-			l= p[sw];
-			M_p_c2nl(data,l,sc);
-			p[sw++]=l;
-			for (; sw<SHA_LBLOCK; sw++)
-				{
-				M_c2nl(data,l);
-				p[sw]=l;
-				}
-			len-=(SHA_CBLOCK-c->num);
-
-			sha1_block(c,p,64);
-			c->num=0;
-			/* drop through and do the rest */
-			}
-		else
-			{
-			c->num+=(int)len;
-			if ((sc+len) < 4) /* ugly, add char's to a word */
-				{
-				l= p[sw];
-				M_p_c2nl_p(data,l,sc,len);
-				p[sw]=l;
-				}
-			else
-				{
-				ew=(c->num>>2);
-				ec=(c->num&0x03);
-				l= p[sw];
-				M_p_c2nl(data,l,sc);
-				p[sw++]=l;
-				for (; sw < ew; sw++)
-					{ M_c2nl(data,l); p[sw]=l; }
-				if (ec)
-					{
-					M_c2nl_p(data,l,ec);
-					p[sw]=l;
-					}
-				}
-			return;
-			}
+	uint64_t len;
+	size_t t;
+	unsigned char tmp[SHA_CBLOCK + sizeof(uint64_t)] = {0x80, 0};
+
+	len = (uint64_t)c->Nl | (uint64_t)c->Nh << 32;
+	t = 64 + 56 - c->Nl % 64;
+	if (t > 64)
+		t -= 64;
+
+	/* length in bits */
+	len <<= 3;
+	be64enc(tmp + t, len);
+	SHA1_Update(c, tmp, t + 8);
+	assert(c->num == 0);
+
+	be32enc(md +  0, c->h0);
+	be32enc(md +  4, c->h1);
+	be32enc(md +  8, c->h2);
+	be32enc(md + 12, c->h3);
+	be32enc(md + 16, c->h4);
+
+	explicit_bzero(c, sizeof(*c));
+}
+
+#ifndef SHA1_ASM
+static void
+/* invariant: len is a multiple of SHA_CBLOCK */
+sha1_block(SHA1_CTX *c, const void *data, size_t len)
+{
+	uint32_t w[16];
+	uint32_t h0 = c->h0, h1 = c->h1, h2 = c->h2, h3 = c->h3, h4 = c->h4;
+	const char *p = data;
+
+	while (len >= SHA_CBLOCK) {
+		size_t i;
+		uint32_t a = h0, b = h1, c = h2, d = h3, e = h4;
+		uint32_t f, t, tmp;
+
+#		pragma unroll
+		for (i = 0; i < 16; i++)
+			w[i] = be32dec(p + 4*i);
+
+#		pragma unroll
+		for (i = 0; i < 16; i++) {
+			f = b & c | ~b & d;
+			t = (a << 5 | a >> 32 - 5) + f + e + w[i & 0xf] + K0;
+			e = d;
+			d = c;
+			c = b << 30 | b >> 32 - 30;
+			b = a;
+			a = t;
 		}
-	/* We can only do the following code for assember, the reason
-	 * being that the sha1_block 'C' version changes the values
-	 * in the 'data' array.  The assember code avoids this and
-	 * copies it to a local array.  I should be able to do this for
-	 * the C version as well....
-	 */
-#if 1
-#if BYTE_ORDER == BIG_ENDIAN || defined(SHA1_ASM)
-	if ((((unsigned int)data)%sizeof(u_int32_t)) == 0)
-		{
-		sw=len/SHA_CBLOCK;
-		if (sw)
-			{
-			sw*=SHA_CBLOCK;
-			sha1_block(c,(u_int32_t *)data,sw);
-			data+=sw;
-			len-=sw;
-			}
+
+#		pragma unroll
+		for (; i < 20; i++) {
+			tmp = w[i - 3 & 0xf] ^ w[i - 8 & 0xf] ^ w[i - 14 & 0xf] ^ w[i & 0xf];
+			w[i & 0xf] = tmp << 1 | tmp >> 32 - 1;
+
+			f = b & c | ~b & d;
+			t = (a << 5 | a >> 32 - 5) + f + e + w[i & 0xf] + K0;
+			e = d;
+			d = c;
+			c = b << 30 | b >> 32 - 30;
+			b = a;
+			a = t;
 		}
-#endif
-#endif
-	/* we now can process the input data in blocks of SHA_CBLOCK
-	 * chars and save the leftovers to c->data. */
-	p=c->data;
-	while (len >= SHA_CBLOCK)
-		{
-#if BYTE_ORDER == BIG_ENDIAN || BYTE_ORDER == LITTLE_ENDIAN
-		if (p != (u_int32_t *)data)
-			memcpy(p,data,SHA_CBLOCK);
-		data+=SHA_CBLOCK;
-#  if BYTE_ORDER == LITTLE_ENDIAN
-#    ifndef SHA1_ASM /* Will not happen */
-		for (sw=(SHA_LBLOCK/4); sw; sw--)
-			{
-			Endian_Reverse32(p[0]);
-			Endian_Reverse32(p[1]);
-			Endian_Reverse32(p[2]);
-			Endian_Reverse32(p[3]);
-			p+=4;
-			}
-		p=c->data;
-#    endif
-#  endif
-#else
-		for (sw=(SHA_BLOCK/4); sw; sw--)
-			{
-			M_c2nl(data,l); *(p++)=l;
-			M_c2nl(data,l); *(p++)=l;
-			M_c2nl(data,l); *(p++)=l;
-			M_c2nl(data,l); *(p++)=l;
-			}
-		p=c->data;
-#endif
-		sha1_block(c,p,64);
-		len-=SHA_CBLOCK;
+
+#		pragma unroll
+		for (; i < 40; i++) {
+			tmp = w[i - 3 & 0xf] ^ w[i - 8 & 0xf] ^ w[i - 14 & 0xf] ^ w[i & 0xf];
+			w[i & 0xf] = tmp << 1 | tmp >> 32 - 1;
+
+			f = b ^ c ^ d;
+			t = (a << 5 | a >> 32 - 5) + f + e + w[i & 0xf] + K1;
+			e = d;
+			d = c;
+			c = b << 30 | b >> 32 - 30;
+			b = a;
+			a = t;
 		}
-	ec=(int)len;
-	c->num=ec;
-	ew=(ec>>2);
-	ec&=0x03;
-
-	for (sw=0; sw < ew; sw++)
-		{ M_c2nl(data,l); p[sw]=l; }
-	M_c2nl_p(data,l,ec);
-	p[sw]=l;
-	}
 
-static void SHA1_Transform(SHA_CTX *c, unsigned char *b)
-	{
-	u_int32_t p[16];
-#if BYTE_ORDER != BIG_ENDIAN
-	u_int32_t *q;
-	int i;
-#endif
+#		pragma unroll
+		for (; i < 60; i++) {
+			tmp = w[i - 3 & 0xf] ^ w[i - 8 & 0xf] ^ w[i - 14 & 0xf] ^ w[i & 0xf];
+			w[i & 0xf] = tmp << 1 | tmp >> 32 - 1;
+
+			f = (b | c) & d | b & c;
+			t = (a << 5 | a >> 32 - 5) + f + e + w[i & 0xf] + K2;
+			e = d;
+			d = c;
+			c = b << 30 | b >> 32 - 30;
+			b = a;
+			a = t;
+		}
 
-#if BYTE_ORDER == BIG_ENDIAN || BYTE_ORDER == LITTLE_ENDIAN
-	memcpy(p,b,64);
-#if BYTE_ORDER == LITTLE_ENDIAN
-	q=p;
-	for (i=(SHA_LBLOCK/4); i; i--)
-		{
-		Endian_Reverse32(q[0]);
-		Endian_Reverse32(q[1]);
-		Endian_Reverse32(q[2]);
-		Endian_Reverse32(q[3]);
-		q+=4;
+#		pragma unroll
+		for (; i < 80; i++) {
+			tmp = w[i - 3 & 0xf] ^ w[i - 8 & 0xf] ^ w[i - 14 & 0xf] ^ w[i & 0xf];
+			w[i & 0xf] = tmp << 1 | tmp >> 32 - 1;
+
+			f = b ^ c ^ d;
+			t = (a << 5 | a >> 32 - 5) + f + e + w[i & 0xf] + K3;
+			e = d;
+			d = c;
+			c = b << 30 | b >> 32 - 30;
+			b = a;
+			a = t;
 		}
-#endif
-#else
-	q=p;
-	for (i=(SHA_LBLOCK/4); i; i--)
-		{
-		u_int32_t l;
-		c2nl(b,l); *(q++)=l;
-		c2nl(b,l); *(q++)=l;
-		c2nl(b,l); *(q++)=l;
-		c2nl(b,l); *(q++)=l; 
-		} 
-#endif
-	sha1_block(c,p,64);
-	}
 
-#ifndef SHA1_ASM
+		h0 += a;
+		h1 += b;
+		h2 += c;
+		h3 += d;
+		h4 += e;
 
-void 
-sha1_block(SHA_CTX *c, const u_int32_t *W, int num)
-{
-	u_int32_t A,B,C,D,E,T;
-	u_int32_t X[16];
-
-	A=c->h0;
-	B=c->h1;
-	C=c->h2;
-	D=c->h3;
-	E=c->h4;
-
-	for (;;)
-		{
-	BODY_00_15( 0,A,B,C,D,E,T,W);
-	BODY_00_15( 1,T,A,B,C,D,E,W);
-	BODY_00_15( 2,E,T,A,B,C,D,W);
-	BODY_00_15( 3,D,E,T,A,B,C,W);
-	BODY_00_15( 4,C,D,E,T,A,B,W);
-	BODY_00_15( 5,B,C,D,E,T,A,W);
-	BODY_00_15( 6,A,B,C,D,E,T,W);
-	BODY_00_15( 7,T,A,B,C,D,E,W);
-	BODY_00_15( 8,E,T,A,B,C,D,W);
-	BODY_00_15( 9,D,E,T,A,B,C,W);
-	BODY_00_15(10,C,D,E,T,A,B,W);
-	BODY_00_15(11,B,C,D,E,T,A,W);
-	BODY_00_15(12,A,B,C,D,E,T,W);
-	BODY_00_15(13,T,A,B,C,D,E,W);
-	BODY_00_15(14,E,T,A,B,C,D,W);
-	BODY_00_15(15,D,E,T,A,B,C,W);
-	BODY_16_19(16,C,D,E,T,A,B,W,W,W,W);
-	BODY_16_19(17,B,C,D,E,T,A,W,W,W,W);
-	BODY_16_19(18,A,B,C,D,E,T,W,W,W,W);
-	BODY_16_19(19,T,A,B,C,D,E,W,W,W,X);
-
-	BODY_20_31(20,E,T,A,B,C,D,W,W,W,X);
-	BODY_20_31(21,D,E,T,A,B,C,W,W,W,X);
-	BODY_20_31(22,C,D,E,T,A,B,W,W,W,X);
-	BODY_20_31(23,B,C,D,E,T,A,W,W,W,X);
-	BODY_20_31(24,A,B,C,D,E,T,W,W,X,X);
-	BODY_20_31(25,T,A,B,C,D,E,W,W,X,X);
-	BODY_20_31(26,E,T,A,B,C,D,W,W,X,X);
-	BODY_20_31(27,D,E,T,A,B,C,W,W,X,X);
-	BODY_20_31(28,C,D,E,T,A,B,W,W,X,X);
-	BODY_20_31(29,B,C,D,E,T,A,W,W,X,X);
-	BODY_20_31(30,A,B,C,D,E,T,W,X,X,X);
-	BODY_20_31(31,T,A,B,C,D,E,W,X,X,X);
-	BODY_32_39(32,E,T,A,B,C,D,X);
-	BODY_32_39(33,D,E,T,A,B,C,X);
-	BODY_32_39(34,C,D,E,T,A,B,X);
-	BODY_32_39(35,B,C,D,E,T,A,X);
-	BODY_32_39(36,A,B,C,D,E,T,X);
-	BODY_32_39(37,T,A,B,C,D,E,X);
-	BODY_32_39(38,E,T,A,B,C,D,X);
-	BODY_32_39(39,D,E,T,A,B,C,X);
-
-	BODY_40_59(40,C,D,E,T,A,B,X);
-	BODY_40_59(41,B,C,D,E,T,A,X);
-	BODY_40_59(42,A,B,C,D,E,T,X);
-	BODY_40_59(43,T,A,B,C,D,E,X);
-	BODY_40_59(44,E,T,A,B,C,D,X);
-	BODY_40_59(45,D,E,T,A,B,C,X);
-	BODY_40_59(46,C,D,E,T,A,B,X);
-	BODY_40_59(47,B,C,D,E,T,A,X);
-	BODY_40_59(48,A,B,C,D,E,T,X);
-	BODY_40_59(49,T,A,B,C,D,E,X);
-	BODY_40_59(50,E,T,A,B,C,D,X);
-	BODY_40_59(51,D,E,T,A,B,C,X);
-	BODY_40_59(52,C,D,E,T,A,B,X);
-	BODY_40_59(53,B,C,D,E,T,A,X);
-	BODY_40_59(54,A,B,C,D,E,T,X);
-	BODY_40_59(55,T,A,B,C,D,E,X);
-	BODY_40_59(56,E,T,A,B,C,D,X);
-	BODY_40_59(57,D,E,T,A,B,C,X);
-	BODY_40_59(58,C,D,E,T,A,B,X);
-	BODY_40_59(59,B,C,D,E,T,A,X);
-
-	BODY_60_79(60,A,B,C,D,E,T,X);
-	BODY_60_79(61,T,A,B,C,D,E,X);
-	BODY_60_79(62,E,T,A,B,C,D,X);
-	BODY_60_79(63,D,E,T,A,B,C,X);
-	BODY_60_79(64,C,D,E,T,A,B,X);
-	BODY_60_79(65,B,C,D,E,T,A,X);
-	BODY_60_79(66,A,B,C,D,E,T,X);
-	BODY_60_79(67,T,A,B,C,D,E,X);
-	BODY_60_79(68,E,T,A,B,C,D,X);
-	BODY_60_79(69,D,E,T,A,B,C,X);
-	BODY_60_79(70,C,D,E,T,A,B,X);
-	BODY_60_79(71,B,C,D,E,T,A,X);
-	BODY_60_79(72,A,B,C,D,E,T,X);
-	BODY_60_79(73,T,A,B,C,D,E,X);
-	BODY_60_79(74,E,T,A,B,C,D,X);
-	BODY_60_79(75,D,E,T,A,B,C,X);
-	BODY_60_79(76,C,D,E,T,A,B,X);
-	BODY_60_79(77,B,C,D,E,T,A,X);
-	BODY_60_79(78,A,B,C,D,E,T,X);
-	BODY_60_79(79,T,A,B,C,D,E,X);
-	
-	c->h0=(c->h0+E)&0xffffffffL; 
-	c->h1=(c->h1+T)&0xffffffffL;
-	c->h2=(c->h2+A)&0xffffffffL;
-	c->h3=(c->h3+B)&0xffffffffL;
-	c->h4=(c->h4+C)&0xffffffffL;
-
-	num-=64;
-	if (num <= 0) break;
-
-	A=c->h0;
-	B=c->h1;
-	C=c->h2;
-	D=c->h3;
-	E=c->h4;
-
-	W+=16;
-		}
+		p += SHA_CBLOCK;
+		len -= SHA_CBLOCK;
 	}
-#endif
 
-void SHA1_Final(unsigned char *md, SHA_CTX *c)
-	{
-	int i,j;
-	u_int32_t l;
-	u_int32_t *p;
-	static unsigned char end[4]={0x80,0x00,0x00,0x00};
-	unsigned char *cp=end;
-
-	/* c->num should definitly have room for at least one more byte. */
-	p=c->data;
-	j=c->num;
-	i=j>>2;
-#ifdef PURIFY
-	if ((j&0x03) == 0) p[i]=0;
+	c->h0 = h0;
+	c->h1 = h1;
+	c->h2 = h2;
+	c->h3 = h3;
+	c->h4 = h4;
+}
 #endif
-	l=p[i];
-	M_p_c2nl(cp,l,j&0x03);
-	p[i]=l;
-	i++;
-	/* i is the next 'undefined word' */
-	if (c->num >= SHA_LAST_BLOCK)
-		{
-		for (; i<SHA_LBLOCK; i++)
-			p[i]=0;
-		sha1_block(c,p,64);
-		i=0;
-		}
-	for (; i<(SHA_LBLOCK-2); i++)
-		p[i]=0;
-	p[SHA_LBLOCK-2]=c->Nh;
-	p[SHA_LBLOCK-1]=c->Nl;
-#if BYTE_ORDER == LITTLE_ENDIAN && defined(SHA1_ASM)
-	Endian_Reverse32(p[SHA_LBLOCK-2]);
-	Endian_Reverse32(p[SHA_LBLOCK-1]);
-#endif
-	sha1_block(c,p,64);
-	cp=md;
-	l=c->h0; nl2c(l,cp);
-	l=c->h1; nl2c(l,cp);
-	l=c->h2; nl2c(l,cp);
-	l=c->h3; nl2c(l,cp);
-	l=c->h4; nl2c(l,cp);
-
-	/* Clear the context state */
-	explicit_bzero(&c, sizeof(c));
-	}
 
 #ifdef WEAK_REFS
 /* When building libmd, provide weak references. Note: this is not