Document standard_partial_byte_{in,out}put_encoding in man pages1.0

Signed-off-by: Mattias Andrée <maandree@kth.se>

46 files changed, 1616 insertions, 3 deletions

diff --git a/libhashsum.h b/libhashsum.h
index cf13a2e..6ac9fc8 100644
--- a/libhashsum.h
+++ b/libhashsum.h
@@ -430,7 +430,7 @@ struct libhashsum_hasher {
 	 * 
 	 * @since  1.0
 	 */
-	unsigned char standard_partial_byte_input_encoding; /* TODO man, test */
+	unsigned char standard_partial_byte_input_encoding; /* TODO test */
 
 	/**
 	 * libhashsum always uses the least significant bits of
@@ -463,7 +463,7 @@ struct libhashsum_hasher {
 	 * 
 	 * @since  1.0
 	 */
-	unsigned char standard_partial_byte_output_encoding; /* TODO man, test */
+	unsigned char standard_partial_byte_output_encoding; /* TODO test */
 
 	/**
 	 * Update the hash state given additional
diff --git a/libhashsum_init_blake224_hasher.3 b/libhashsum_init_blake224_hasher.3
index e25f92b..ffdefe4 100644
--- a/libhashsum_init_blake224_hasher.3
+++ b/libhashsum_init_blake224_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blake224_hasher - initialise state for BLAKE224 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -212,6 +214,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKE224 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blake256_hasher.3 b/libhashsum_init_blake256_hasher.3
index 9baf5e3..86df6df 100644
--- a/libhashsum_init_blake256_hasher.3
+++ b/libhashsum_init_blake256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blake256_hasher - initialise state for BLAKE256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -212,6 +214,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKE256 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blake2b_hasher.3 b/libhashsum_init_blake2b_hasher.3
index 7d4ffa4..70bb571 100644
--- a/libhashsum_init_blake2b_hasher.3
+++ b/libhashsum_init_blake2b_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blake2b_hasher - initialise state for BLAKE2b hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -287,6 +289,32 @@ is not divisible by 8.
 .I keybits
 is greater than 512.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKE2b does not support non-whole octets, so
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED .
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blake2s_hasher.3 b/libhashsum_init_blake2s_hasher.3
index 5250708..4f97f08 100644
--- a/libhashsum_init_blake2s_hasher.3
+++ b/libhashsum_init_blake2s_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blake2s_hasher - initialise state for BLAKE2s hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -287,6 +289,32 @@ is not divisible by 8.
 .I keybits
 is greater than 256.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKE2s does not support non-whole octets, so
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED .
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blake384_hasher.3 b/libhashsum_init_blake384_hasher.3
index 6882cba..3e72083 100644
--- a/libhashsum_init_blake384_hasher.3
+++ b/libhashsum_init_blake384_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blake384_hasher - initialise state for BLAKE384 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -212,6 +214,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKE384 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blake512_hasher.3 b/libhashsum_init_blake512_hasher.3
index efbebe0..2e10d32 100644
--- a/libhashsum_init_blake512_hasher.3
+++ b/libhashsum_init_blake512_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blake512_hasher - initialise state for BLAKE512 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -212,6 +214,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKE512 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blake_hasher.3 b/libhashsum_init_blake_hasher.3
index 1535428..8a2fcd3 100644
--- a/libhashsum_init_blake_hasher.3
+++ b/libhashsum_init_blake_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blake_hasher - initialise state for BLAKE hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -268,6 +270,41 @@ but
 .I saltbytes
 is not 32.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKE always output a whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blakeb_hasher.3 b/libhashsum_init_blakeb_hasher.3
index 2650f02..ded8687 100644
--- a/libhashsum_init_blakeb_hasher.3
+++ b/libhashsum_init_blakeb_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blakeb_hasher - initialise state for BLAKEb hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -225,6 +227,41 @@ Support was excluded at compile time.
 .I hashbits
 is either 384 nor 512.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKEb always output a whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_blakes_hasher.3 b/libhashsum_init_blakes_hasher.3
index bf16b9b..0c604f2 100644
--- a/libhashsum_init_blakes_hasher.3
+++ b/libhashsum_init_blakes_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_blakes_hasher - initialise state for BLAKEs hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -225,6 +227,41 @@ Support was excluded at compile time.
 .I hashbits
 is either 224 nor 256.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+BLAKEs always output a whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_hasher.3 b/libhashsum_init_hasher.3
index a61b00e..5bb2b62 100644
--- a/libhashsum_init_hasher.3
+++ b/libhashsum_init_hasher.3
@@ -15,6 +15,8 @@ libhashsum_init_hasher - initialise state for hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -239,7 +241,7 @@ Selects BLAKE2s (BLAKE2). See
 for more information.
 .TP
 .B LIBHASHSUM_BLAKE2B
-Selects BLAKE2b (BLAKE). See
+Selects BLAKE2b (BLAKE2). See
 .BR libhashsum_init_blake2b_hasher (3)
 for more information.
 .PP
@@ -487,6 +489,77 @@ is unrecognised or unsupported.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+If the hash function does not support non-whole
+input octets,
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED .
+.PP
+If the hash function supports non-whole input
+octets, and uses the least significant bits
+in its standard, which is the same behaviour
+as implemented by libhashsum,
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT .
+.PP
+If the hash function supports non-whole input
+octets, and uses the most significant bits
+in its standard, which is the opposite behaviour
+of what is implemented by libhashsum,
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT .
+This means that the partial octet must be
+reverted to convert between the libhashsum's
+encoding and the hash function's standard's
+encoding.
+.PP
+If the hash function does not support non-whole
+octet hashes,
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED .
+.PP
+If the hash function supports non-whole octet
+hashes, and uses the least significant bits
+in its standard, which is the same behaviour
+as implemented by libhashsum,
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT .
+.PP
+If the hash function supports non-whole octet
+hashes, and uses the most significant bits
+in its standard, which is the opposite behaviour
+of what is implemented by libhashsum,
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT .
+This means that the last octet, if partial,
+must be reverted to convert between the
+libhashsum's encoding and the hash function's
+standard's encoding.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_hasher_from_string.3 b/libhashsum_init_hasher_from_string.3
index 901d3f5..bc0cb4a 100644
--- a/libhashsum_init_hasher_from_string.3
+++ b/libhashsum_init_hasher_from_string.3
@@ -13,6 +13,8 @@ libhashsum_init_hasher_from_string - initialise state for hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -313,6 +315,77 @@ an invalid combination of parameters.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+If the hash function does not support non-whole
+input octets,
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED .
+.PP
+If the hash function supports non-whole input
+octets, and uses the least significant bits
+in its standard, which is the same behaviour
+as implemented by libhashsum,
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT .
+.PP
+If the hash function supports non-whole input
+octets, and uses the most significant bits
+in its standard, which is the opposite behaviour
+of what is implemented by libhashsum,
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT .
+This means that the partial octet must be
+reverted to convert between the libhashsum's
+encoding and the hash function's standard's
+encoding.
+.PP
+If the hash function does not support non-whole
+octet hashes,
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED .
+.PP
+If the hash function supports non-whole octet
+hashes, and uses the least significant bits
+in its standard, which is the same behaviour
+as implemented by libhashsum,
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT .
+.PP
+If the hash function supports non-whole octet
+hashes, and uses the most significant bits
+in its standard, which is the opposite behaviour
+of what is implemented by libhashsum,
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT .
+This means that the last octet, if partial,
+must be reverted to convert between the
+libhashsum's encoding and the hash function's
+standard's encoding.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_keccak_224_hasher.3 b/libhashsum_init_keccak_224_hasher.3
index 74c5db5..3252f86 100644
--- a/libhashsum_init_keccak_224_hasher.3
+++ b/libhashsum_init_keccak_224_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_keccak_224_hasher - initialise state for Keccak-224 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -245,6 +247,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+Keccak-224 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_keccak_256_hasher.3 b/libhashsum_init_keccak_256_hasher.3
index f73ea91..ce87a81 100644
--- a/libhashsum_init_keccak_256_hasher.3
+++ b/libhashsum_init_keccak_256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_keccak_256_hasher - initialise state for Keccak-256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -245,6 +247,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+Keccak-256 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_keccak_384_hasher.3 b/libhashsum_init_keccak_384_hasher.3
index 7528e4f..a17d2f7 100644
--- a/libhashsum_init_keccak_384_hasher.3
+++ b/libhashsum_init_keccak_384_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_keccak_384_hasher - initialise state for Keccak-384 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -245,6 +247,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+Keccak-384 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_keccak_512_hasher.3 b/libhashsum_init_keccak_512_hasher.3
index 06846ed..c175413 100644
--- a/libhashsum_init_keccak_512_hasher.3
+++ b/libhashsum_init_keccak_512_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_keccak_512_hasher - initialise state for Keccak-512 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -245,6 +247,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+Keccak-512 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_keccak_hasher.3 b/libhashsum_init_keccak_hasher.3
index 1712da7..b342662 100644
--- a/libhashsum_init_keccak_hasher.3
+++ b/libhashsum_init_keccak_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_keccak_hasher - initialise state for Keccak hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -334,6 +336,36 @@ and
 is invalid (possibly any single value
 is invalid).
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+Keccak supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_md2_hasher.3 b/libhashsum_init_md2_hasher.3
index 76cdf0b..51a388f 100644
--- a/libhashsum_init_md2_hasher.3
+++ b/libhashsum_init_md2_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_md2_hasher - initialise state for MD2 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -186,6 +188,32 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+MD2 does not support non-whole octets, so
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED .
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_md4_hasher.3 b/libhashsum_init_md4_hasher.3
index adbb8a3..8f752e2 100644
--- a/libhashsum_init_md4_hasher.3
+++ b/libhashsum_init_md4_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_md4_hasher - initialise state for MD4 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -192,6 +194,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+MD4 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_md5_hasher.3 b/libhashsum_init_md5_hasher.3
index 95abd7b..6b3365f 100644
--- a/libhashsum_init_md5_hasher.3
+++ b/libhashsum_init_md5_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_md5_hasher - initialise state for MD5 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -192,6 +194,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+MD5 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_rawshake128_hasher.3 b/libhashsum_init_rawshake128_hasher.3
index 26ec70c..d180c57 100644
--- a/libhashsum_init_rawshake128_hasher.3
+++ b/libhashsum_init_rawshake128_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_rawshake128_hasher - initialise state for RawSHAKE128 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -269,6 +271,36 @@ Insufficient memory available.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RawSHAKE128 supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_rawshake256_hasher.3 b/libhashsum_init_rawshake256_hasher.3
index ad37c27..57bca9e 100644
--- a/libhashsum_init_rawshake256_hasher.3
+++ b/libhashsum_init_rawshake256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_rawshake256_hasher - initialise state for RawSHAKE256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -269,6 +271,36 @@ Insufficient memory available.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RawSHAKE256 supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_rawshake512_hasher.3 b/libhashsum_init_rawshake512_hasher.3
index bef15c0..4f5b252 100644
--- a/libhashsum_init_rawshake512_hasher.3
+++ b/libhashsum_init_rawshake512_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_rawshake512_hasher - initialise state for RawSHAKE512 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -269,6 +271,36 @@ Insufficient memory available.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RawSHAKE512 supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_rawshake_hasher.3 b/libhashsum_init_rawshake_hasher.3
index 6fa7416..ac93630 100644
--- a/libhashsum_init_rawshake_hasher.3
+++ b/libhashsum_init_rawshake_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_rawshake_hasher - initialise state for RawSHAKE hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -282,6 +284,36 @@ is neither 128, 256, nor 512.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RawSHAKE supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_ripemd_128_hasher.3 b/libhashsum_init_ripemd_128_hasher.3
index 4093084..bdbc7e8 100644
--- a/libhashsum_init_ripemd_128_hasher.3
+++ b/libhashsum_init_ripemd_128_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_ripemd_128_hasher - initialise state for RIPEMD-128 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -192,6 +194,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RIPEMD-128 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_ripemd_160_hasher.3 b/libhashsum_init_ripemd_160_hasher.3
index 9a80caa..47d65c2 100644
--- a/libhashsum_init_ripemd_160_hasher.3
+++ b/libhashsum_init_ripemd_160_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_ripemd_160_hasher - initialise state for RIPEMD-160 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -192,6 +194,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RIPEMD-160 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_ripemd_256_hasher.3 b/libhashsum_init_ripemd_256_hasher.3
index 1d83bce..97bb7af 100644
--- a/libhashsum_init_ripemd_256_hasher.3
+++ b/libhashsum_init_ripemd_256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_ripemd_256_hasher - initialise state for RIPEMD-256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -192,6 +194,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RIPEMD-256 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_ripemd_320_hasher.3 b/libhashsum_init_ripemd_320_hasher.3
index 41b2c2a..eb5f7e9 100644
--- a/libhashsum_init_ripemd_320_hasher.3
+++ b/libhashsum_init_ripemd_320_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_ripemd_320_hasher - initialise state for RIPEMD-320 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -192,6 +194,42 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+RIPEMD-320 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the most
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_MOST_SIGNIFICANT ,
+which the opposite behaviour of what libhashsum
+implements, meaning that the last octet most be
+reversed when converting between the hash function's
+standard representation and libhashsum's
+representation.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha0_hasher.3 b/libhashsum_init_sha0_hasher.3
index 571c065..f943fa9 100644
--- a/libhashsum_init_sha0_hasher.3
+++ b/libhashsum_init_sha0_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha0_hasher - initialise state for SHA-0 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -193,6 +195,37 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-0 always output a fixed, whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha1_hasher.3 b/libhashsum_init_sha1_hasher.3
index fb4d18d..936f7cc 100644
--- a/libhashsum_init_sha1_hasher.3
+++ b/libhashsum_init_sha1_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha1_hasher - initialise state for SHA-1 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -193,6 +195,37 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-1 always output a fixed, whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha2_hasher.3 b/libhashsum_init_sha2_hasher.3
index c1d7d91..173b754 100644
--- a/libhashsum_init_sha2_hasher.3
+++ b/libhashsum_init_sha2_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha2_hasher - initialise state for SHA-2 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -245,6 +247,37 @@ was 32 but
 .I hashbits
 was 384 or 512.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-2 always output a whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha3_224_hasher.3 b/libhashsum_init_sha3_224_hasher.3
index ba5a6da..693be8b 100644
--- a/libhashsum_init_sha3_224_hasher.3
+++ b/libhashsum_init_sha3_224_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha3_224_hasher - initialise state for SHA-3-224 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -244,6 +246,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA3-224 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha3_256_hasher.3 b/libhashsum_init_sha3_256_hasher.3
index 8e862d2..41f4eb0 100644
--- a/libhashsum_init_sha3_256_hasher.3
+++ b/libhashsum_init_sha3_256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha3_256_hasher - initialise state for SHA-3-256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -244,6 +246,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA3-256 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha3_384_hasher.3 b/libhashsum_init_sha3_384_hasher.3
index 8bdcdf2..55b6490 100644
--- a/libhashsum_init_sha3_384_hasher.3
+++ b/libhashsum_init_sha3_384_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha3_384_hasher - initialise state for SHA-3-384 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -244,6 +246,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA3-384 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha3_512_hasher.3 b/libhashsum_init_sha3_512_hasher.3
index 9106b64..444d518 100644
--- a/libhashsum_init_sha3_512_hasher.3
+++ b/libhashsum_init_sha3_512_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha3_512_hasher - initialise state for SHA-3-512 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -244,6 +246,38 @@ Support was excluded at compile time.
 .B ENOMEM
 Insufficient memory available.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA3-512 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha3_hasher.3 b/libhashsum_init_sha3_hasher.3
index 89ab925..cbd01d4 100644
--- a/libhashsum_init_sha3_hasher.3
+++ b/libhashsum_init_sha3_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha3_hasher - initialise state for SHA-3 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -252,6 +254,37 @@ Insufficient memory available.
 .I hashbits
 is neither 224, 245, 384, nor 512.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-3 always output a whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet
+input, and in its standard uses the least
+significant bits of non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha_224_hasher.3 b/libhashsum_init_sha_224_hasher.3
index b5cffa0..ed6d957 100644
--- a/libhashsum_init_sha_224_hasher.3
+++ b/libhashsum_init_sha_224_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha_224_hasher - initialise state for SHA-224 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -186,6 +188,37 @@ is returned, the state of
 .I *hasher
 is undefined.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-224 always output a fixed, whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH ERRORS
 The
 .B libhashsum_init_sha_224_hasher
diff --git a/libhashsum_init_sha_256_hasher.3 b/libhashsum_init_sha_256_hasher.3
index edb1209..cf73e23 100644
--- a/libhashsum_init_sha_256_hasher.3
+++ b/libhashsum_init_sha_256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha_256_hasher - initialise state for SHA-256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -194,6 +196,37 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-256 always output a fixed, whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha_384_hasher.3 b/libhashsum_init_sha_384_hasher.3
index ad0ab38..3be0a44 100644
--- a/libhashsum_init_sha_384_hasher.3
+++ b/libhashsum_init_sha_384_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha_384_hasher - initialise state for SHA-384 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -194,6 +196,37 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-384 always output a fixed, whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha_512_224_hasher.3 b/libhashsum_init_sha_512_224_hasher.3
index 3810bc2..cdbb75d 100644
--- a/libhashsum_init_sha_512_224_hasher.3
+++ b/libhashsum_init_sha_512_224_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha_512_224_hasher - initialise state for SHA-512/224 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -194,6 +196,38 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-521/224 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha_512_256_hasher.3 b/libhashsum_init_sha_512_256_hasher.3
index 76912c7..6100c6f 100644
--- a/libhashsum_init_sha_512_256_hasher.3
+++ b/libhashsum_init_sha_512_256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha_512_256_hasher - initialise state for SHA-512/256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -194,6 +196,38 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-512/256 always output a fixed, whole number of
+octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_sha_512_hasher.3 b/libhashsum_init_sha_512_hasher.3
index eba1cd9..7dc87ba 100644
--- a/libhashsum_init_sha_512_hasher.3
+++ b/libhashsum_init_sha_512_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_sha_512_hasher - initialise state for SHA-512 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -194,6 +196,37 @@ function fails if:
 .B ENOSYS
 Support was excluded at compile time.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHA-512 always output a fixed, whole number of octets, so
+.I this->standard_partial_byte_output_encoding
+will be set to
+.IR LIBHASHSUM_UNSUPPORTED ,
+however, the hash function allows non-whole octet input,
+and in its standard uses the least significant bits of
+non-whole octets, thus
+.I this->standard_partial_byte_input_encoding
+will be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_shake128_hasher.3 b/libhashsum_init_shake128_hasher.3
index 160b82d..877dd29 100644
--- a/libhashsum_init_shake128_hasher.3
+++ b/libhashsum_init_shake128_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_shake128_hasher - initialise state for SHAKE128 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -269,6 +271,36 @@ Insufficient memory available.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHAKE128 supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_shake256_hasher.3 b/libhashsum_init_shake256_hasher.3
index a38f405..3de4501 100644
--- a/libhashsum_init_shake256_hasher.3
+++ b/libhashsum_init_shake256_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_shake256_hasher - initialise state for SHAKE256 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -269,6 +271,36 @@ Insufficient memory available.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHAKE256 supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_shake512_hasher.3 b/libhashsum_init_shake512_hasher.3
index 22630e2..547da3c 100644
--- a/libhashsum_init_shake512_hasher.3
+++ b/libhashsum_init_shake512_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_shake512_hasher - initialise state for SHAKE512 hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -269,6 +271,36 @@ Insufficient memory available.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHAKE512 supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.
 
diff --git a/libhashsum_init_shake_hasher.3 b/libhashsum_init_shake_hasher.3
index e551211..5ab1320 100644
--- a/libhashsum_init_shake_hasher.3
+++ b/libhashsum_init_shake_hasher.3
@@ -13,6 +13,8 @@ libhashsum_init_shake_hasher - initialise state for SHAKE hashing
 	size_t \fIhash_size\fP;
 	unsigned char *\fIhash_output\fP;
 	unsigned char \fIsupports_non_whole_bytes\fP;
+	unsigned char \fIstandard_partial_byte_input_encoding\fP;
+	unsigned char \fIstandard_partial_byte_output_encoding\fP;
 	size_t (*\fIprocess\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP);
 	int (*\fIfinalise_const\fP)(struct libhashsum_hasher *\fPthis\fP, const void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP);
 	int (*\fIfinalise\fP)(struct libhashsum_hasher *\fPthis\fP, void *\fPdata\fP, size_t \fPbytes\fP, unsigned \fPextra_bits\fP, size_t \fPsize\fP);
@@ -282,6 +284,36 @@ is neither 128, 256, nor 512.
 .I hashbits
 is too large.
 
+.SH EXTENDED DESCRIPTION
+libhashsum has normalises the all implemented hash
+functions to always use the least significant bits
+in non-whole octets, however each hash function has
+its unstandarded. To make it easier to create an
+application the use the same encoding of partial
+octets as other application using any particular
+hash function,
+.B struct libhashsum_hasher
+contains two fields:
+.I standard_partial_byte_input_encoding
+and
+.IR standard_partial_byte_output_encoding ;
+which are merely informtional. They are not set to
+specify how libhashsum expects and encodes non-whole
+octets, but rather specify how partial bytes are
+encoded in the reference implementation or
+specification of a hash function.
+.PP
+SHAKE supports non-whole octet both in its
+input and its output, and in its standard uses
+the least significant bits of non-whole octets
+both in the input and in the output, thus
+.I this->standard_partial_byte_input_encoding
+and
+.I this->standard_partial_byte_output_encoding
+will both be set to
+.IR LIBHASHSUM_LEAST_SIGNIFICANT ,
+which the same behaviour as libhashsum implements.
+
 .SH HISTORY
 libhashsum 1.0.