s0 = sigma0_256(s0); \	s1 = W256[(j+14)&0x0f]; \	s1 = sigma1_256(s1); \	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \	     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \	(d) += T1; \	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \	j++void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {	sha2_word32	a, b, c, d, e, f, g, h, s0, s1;	sha2_word32	T1, *W256;	int		j;	W256 = (sha2_word32*)context->buffer;	/* Initialize registers with the prev. intermediate value */	a = context->state[0];	b = context->state[1];	c = context->state[2];	d = context->state[3];	e = context->state[4];	f = context->state[5];	g = context->state[6];	h = context->state[7];	j = 0;	do {		/* Rounds 0 to 15 (unrolled): */		ROUND256_0_TO_15(a,b,c,d,e,f,g,h);		ROUND256_0_TO_15(h,a,b,c,d,e,f,g);		ROUND256_0_TO_15(g,h,a,b,c,d,e,f);		ROUND256_0_TO_15(f,g,h,a,b,c,d,e);		ROUND256_0_TO_15(e,f,g,h,a,b,c,d);		ROUND256_0_TO_15(d,e,f,g,h,a,b,c);		ROUND256_0_TO_15(c,d,e,f,g,h,a,b);		ROUND256_0_TO_15(b,c,d,e,f,g,h,a);	} while (j < 16);	/* Now for the remaining rounds to 64: */	do {		ROUND256(a,b,c,d,e,f,g,h);		ROUND256(h,a,b,c,d,e,f,g);		ROUND256(g,h,a,b,c,d,e,f);		ROUND256(f,g,h,a,b,c,d,e);		ROUND256(e,f,g,h,a,b,c,d);		ROUND256(d,e,f,g,h,a,b,c);		ROUND256(c,d,e,f,g,h,a,b);		ROUND256(b,c,d,e,f,g,h,a);	} while (j < 64);	/* Compute the current intermediate hash value */	context->state[0] += a;	context->state[1] += b;	context->state[2] += c;	context->state[3] += d;	context->state[4] += e;	context->state[5] += f;	context->state[6] += g;	context->state[7] += h;	/* Clean up */	a = b = c = d = e = f = g = h = T1 = 0;}#else /* SHA2_UNROLL_TRANSFORM */void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {	sha2_word32	a, b, c, d, e, f, g, h, s0, s1;	sha2_word32	T1, T2, *W256;	int		j;	W256 = (sha2_word32*)context->buffer;	/* Initialize registers with the prev. intermediate value */	a = context->state[0];	b = context->state[1];	c = context->state[2];	d = context->state[3];	e = context->state[4];	f = context->state[5];	g = context->state[6];	h = context->state[7];	j = 0;	do {#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN		/* Copy data while converting to host byte order */		REVERSE32(*data++,W256[j]);		/* Apply the SHA-256 compression function to update a..h */		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];#else /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */		/* Apply the SHA-256 compression function to update a..h with copy */		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);#endif /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */		T2 = Sigma0_256(a) + Maj(a, b, c);		h = g;		g = f;		f = e;		e = d + T1;		d = c;		c = b;		b = a;		a = T1 + T2;		j++;	} while (j < 16);	do {		/* Part of the message block expansion: */		s0 = W256[(j+1)&0x0f];		s0 = sigma0_256(s0);		s1 = W256[(j+14)&0x0f];			s1 = sigma1_256(s1);		/* Apply the SHA-256 compression function to update a..h */		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + 		     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);		T2 = Sigma0_256(a) + Maj(a, b, c);		h = g;		g = f;		f = e;		e = d + T1;		d = c;		c = b;		b = a;		a = T1 + T2;		j++;	} while (j < 64);	/* Compute the current intermediate hash value */	context->state[0] += a;	context->state[1] += b;	context->state[2] += c;	context->state[3] += d;	context->state[4] += e;	context->state[5] += f;	context->state[6] += g;	context->state[7] += h;	/* Clean up */	a = b = c = d = e = f = g = h = T1 = T2 = 0;}#endif /* SHA2_UNROLL_TRANSFORM */void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {	unsigned int	freespace, usedspace;	if (len == 0) {		/* Calling with no data is valid - we do nothing */		return;	}	/* Sanity check: */	assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0);#if MINIX_64BIT	usedspace= rem64u(context->bitcount, SHA256_BLOCK_LENGTH*8)/8;#else /* !MINIX_64BIT */	usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;#endif /* MINIX_64BIT */	if (usedspace > 0) {		/* Calculate how much free space is available in the buffer */		freespace = SHA256_BLOCK_LENGTH - usedspace;		if (len >= freespace) {			/* Fill the buffer completely and process it */			bcopy(data, &context->buffer[usedspace], freespace);#if MINIX_64BIT			context->bitcount= add64u(context->bitcount,				freespace << 3);#else /* !MINIX_64BIT */			context->bitcount += freespace << 3;#endif /* MINIX_64BIT */			len -= freespace;			data += freespace;			SHA256_Transform(context, (sha2_word32*)context->buffer);		} else {			/* The buffer is not yet full */			bcopy(data, &context->buffer[usedspace], len);#if MINIX_64BIT			context->bitcount= add64u(context->bitcount, len << 3);#else /* !MINIX_64BIT */			context->bitcount += len << 3;#endif /* MINIX_64BIT */			/* Clean up: */			usedspace = freespace = 0;			return;		}	}	while (len >= SHA256_BLOCK_LENGTH) {		/* Process as many complete blocks as we can */		SHA256_Transform(context, (const sha2_word32*)data);#if MINIX_64BIT		context->bitcount= add64u(context->bitcount,			SHA256_BLOCK_LENGTH << 3);#else /* !MINIX_64BIT */		context->bitcount += SHA256_BLOCK_LENGTH << 3;#endif /* MINIX_64BIT */		len -= SHA256_BLOCK_LENGTH;		data += SHA256_BLOCK_LENGTH;	}	if (len > 0) {		/* There's left-overs, so save 'em */		bcopy(data, context->buffer, len);#if MINIX_64BIT		context->bitcount= add64u(context->bitcount, len << 3);#else /* !MINIX_64BIT */		context->bitcount += len << 3;#endif /* MINIX_64BIT */	}	/* Clean up: */	usedspace = freespace = 0;}void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {	sha2_word32	*d = (sha2_word32*)digest;	unsigned int	usedspace;	/* Sanity check: */	assert(context != (SHA256_CTX*)0);	/* If no digest buffer is passed, we don't bother doing this: */	if (digest != (sha2_byte*)0) {#if MINIX_64BIT		usedspace= rem64u(context->bitcount, SHA256_BLOCK_LENGTH*8)/8;#else /* !MINIX_64BIT */		usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;#endif /* MINIX_64BIT */#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN		/* Convert FROM host byte order */		REVERSE64(context->bitcount,context->bitcount);#endif		if (usedspace > 0) {			/* Begin padding with a 1 bit: */			context->buffer[usedspace++] = 0x80;			if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {				/* Set-up for the last transform: */				bzero(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);			} else {				if (usedspace < SHA256_BLOCK_LENGTH) {					bzero(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);				}				/* Do second-to-last transform: */				SHA256_Transform(context, (sha2_word32*)context->buffer);				/* And set-up for the last transform: */				bzero(context->buffer, SHA256_SHORT_BLOCK_LENGTH);			}		} else {			/* Set-up for the last transform: */			bzero(context->buffer, SHA256_SHORT_BLOCK_LENGTH);			/* Begin padding with a 1 bit: */			*context->buffer = 0x80;		}		/* Set the bit count: */		*(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;		/* Final transform: */		SHA256_Transform(context, (sha2_word32*)context->buffer);#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN		{			/* Convert TO host byte order */			int	j;			for (j = 0; j < 8; j++) {				REVERSE32(context->state[j],context->state[j]);				*d++ = context->state[j];			}		}#else		bcopy(context->state, d, SHA256_DIGEST_LENGTH);#endif	}	/* Clean up state data: */	bzero(context, sizeof(context));	usedspace = 0;}char *SHA256_End(SHA256_CTX* context, char buffer[]) {	sha2_byte	digest[SHA256_DIGEST_LENGTH], *d = digest;	int		i;	/* Sanity check: */	assert(context != (SHA256_CTX*)0);	if (buffer != (char*)0) {		SHA256_Final(digest, context);		for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];			*buffer++ = sha2_hex_digits[*d & 0x0f];			d++;		}		*buffer = (char)0;	} else {		bzero(context, sizeof(context));	}	bzero(digest, SHA256_DIGEST_LENGTH);	return buffer;}char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {	SHA256_CTX	context;	SHA256_Init(&context);	SHA256_Update(&context, data, len);	return SHA256_End(&context, digest);}#if !NO_64BIT/*** SHA-512: *********************************************************/void SHA512_Init(SHA512_CTX* context) {	if (context == (SHA512_CTX*)0) {		return;	}	bcopy(sha512_initial_hash_value, context->state, SHA512_DIGEST_LENGTH);	bzero(context->buffer, SHA512_BLOCK_LENGTH);	context->bitcount[0] = context->bitcount[1] =  0;}#ifdef SHA2_UNROLL_TRANSFORM/* Unrolled SHA-512 round macros: */#if SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)	\	REVERSE64(*data++, W512[j]); \	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \             K512[j] + W512[j]; \	(d) += T1, \	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \	j++#else /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)	\	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \             K512[j] + (W512[j] = *data++); \	(d) += T1; \	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \	j++#endif /* SHA2_BYTE_ORDER == SHA2_LITTLE_ENDIAN */#define ROUND512(a,b,c,d,e,f,g,h)	\	s0 = W512[(j+1)&0x0f]; \	s0 = sigma0_512(s0); \	s1 = W512[(j+14)&0x0f]; \	s1 = sigma1_512(s1); \	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \             (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \	(d) += T1; \	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \	j++void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {