diff --git a/pubkey.h b/pubkey.h
index 6e0d43fa..965dcb56 100644
--- a/pubkey.h
+++ b/pubkey.h
@@ -99,6 +99,9 @@ public:
 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE RandomizedTrapdoorFunction : public TrapdoorFunctionBounds
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~RandomizedTrapdoorFunction() { }
+#endif
 
 	//! \brief Applies the trapdoor function, using random data if required
 	//! \param rng a \p RandomNumberGenerator derived class
@@ -113,10 +116,6 @@ public:
 	//! \returns \p true if the encryption algorithm is randomized, \p false otherwise
 	//! \details If \p IsRandomized() returns \p false, then \p NullRNG() can be used.
 	virtual bool IsRandomized() const {return true;}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~RandomizedTrapdoorFunction() { }
-#endif
 };
 
 //! \class TrapdoorFunction
@@ -235,6 +234,10 @@ template <class TFI, class MEI>
 class CRYPTOPP_NO_VTABLE TF_Base
 {
 protected:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~TF_Base() { }
+#endif
+
 	virtual const TrapdoorFunctionBounds & GetTrapdoorFunctionBounds() const =0;
 
 	typedef TFI TrapdoorFunctionInterface;
@@ -242,10 +245,6 @@ protected:
 
 	typedef MEI MessageEncodingInterface;
 	virtual const MessageEncodingInterface & GetMessageEncodingInterface() const =0;
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~TF_Base() { }
-#endif
 };
 
 // ********************************************************
@@ -257,6 +256,10 @@ template <class BASE>
 class CRYPTOPP_NO_VTABLE PK_FixedLengthCryptoSystemImpl : public BASE
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~PK_FixedLengthCryptoSystemImpl() { }
+#endif
+
 	size_t MaxPlaintextLength(size_t ciphertextLength) const
 		{return ciphertextLength == FixedCiphertextLength() ? FixedMaxPlaintextLength() : 0;}
 	size_t CiphertextLength(size_t plaintextLength) const
@@ -264,10 +267,6 @@ public:
 
 	virtual size_t FixedMaxPlaintextLength() const =0;
 	virtual size_t FixedCiphertextLength() const =0;
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~PK_FixedLengthCryptoSystemImpl() { }
-#endif
 };
 
 //! \class TF_CryptoSystemBase
@@ -278,6 +277,10 @@ template <class INTERFACE, class BASE>
 class CRYPTOPP_NO_VTABLE TF_CryptoSystemBase : public PK_FixedLengthCryptoSystemImpl<INTERFACE>, protected BASE
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~TF_CryptoSystemBase() { }
+#endif
+
 	bool ParameterSupported(const char *name) const {return this->GetMessageEncodingInterface().ParameterSupported(name);}
 	size_t FixedMaxPlaintextLength() const {return this->GetMessageEncodingInterface().MaxUnpaddedLength(PaddedBlockBitLength());}
 	size_t FixedCiphertextLength() const {return this->GetTrapdoorFunctionBounds().MaxImage().ByteCount();}
@@ -286,10 +289,6 @@ protected:
 	size_t PaddedBlockByteLength() const {return BitsToBytes(PaddedBlockBitLength());}
 	// Coverity finding on potential overflow/underflow.
 	size_t PaddedBlockBitLength() const {return SaturatingSubtract(this->GetTrapdoorFunctionBounds().PreimageBound().BitCount(),1U);}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~TF_CryptoSystemBase() { }
-#endif
 };
 
 //! \class TF_DecryptorBase
@@ -297,11 +296,11 @@ protected:
 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_DecryptorBase : public TF_CryptoSystemBase<PK_Decryptor, TF_Base<TrapdoorFunctionInverse, PK_EncryptionMessageEncodingMethod> >
 {
 public:
-	DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
-	
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
 	virtual ~TF_DecryptorBase() { }
 #endif
+
+	DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
 };
 
 //! \class TF_DecryptorBase
@@ -309,11 +308,11 @@ public:
 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_EncryptorBase : public TF_CryptoSystemBase<PK_Encryptor, TF_Base<RandomizedTrapdoorFunction, PK_EncryptionMessageEncodingMethod> >
 {
 public:
-	void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
-
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
 	virtual ~TF_EncryptorBase() { }
 #endif
+
+	void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
 };
 
 // ********************************************************
@@ -486,6 +485,10 @@ template <class INTERFACE, class BASE>
 class CRYPTOPP_NO_VTABLE TF_SignatureSchemeBase : public INTERFACE, protected BASE
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~TF_SignatureSchemeBase() { }
+#endif
+
 	size_t SignatureLength() const 
 		{return this->GetTrapdoorFunctionBounds().MaxPreimage().ByteCount();}
 	size_t MaxRecoverableLength() const 
@@ -499,10 +502,6 @@ public:
 		{return this->GetMessageEncodingInterface().AllowNonrecoverablePart();}
 	bool RecoverablePartFirst() const 
 		{return this->GetMessageEncodingInterface().RecoverablePartFirst();}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~TF_SignatureSchemeBase() { }
-#endif
 
 protected:
 	size_t MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}
@@ -516,25 +515,25 @@ protected:
 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_SignerBase : public TF_SignatureSchemeBase<PK_Signer, TF_Base<RandomizedTrapdoorFunctionInverse, PK_SignatureMessageEncodingMethod> >
 {
 public:
-	void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const;
-	size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const;
-	
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
 	virtual ~TF_SignerBase() { }
 #endif
+
+	void InputRecoverableMessage(PK_MessageAccumulator &messageAccumulator, const byte *recoverableMessage, size_t recoverableMessageLength) const;
+	size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const;
 };
 
 //! _
 class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_VerifierBase : public TF_SignatureSchemeBase<PK_Verifier, TF_Base<TrapdoorFunction, PK_SignatureMessageEncodingMethod> >
 {
 public:
-	void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const;
-	bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const;
-	DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &recoveryAccumulator) const;
-	
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
 	virtual ~TF_VerifierBase() { }
 #endif
+
+	void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const;
+	bool VerifyAndRestart(PK_MessageAccumulator &messageAccumulator) const;
+	DecodingResult RecoverAndRestart(byte *recoveredMessage, PK_MessageAccumulator &recoveryAccumulator) const;
 };
 
 // ********************************************************
@@ -565,6 +564,10 @@ public:
 	typedef SCHEME_OPTIONS SchemeOptions;
 	typedef KEY_CLASS KeyClass;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~TF_ObjectImplBase() { }
+#endif
+
 	PublicKey & AccessPublicKey() {return AccessKey();}
 	const PublicKey & GetPublicKey() const {return GetKey();}
 
@@ -585,10 +588,6 @@ public:
 	{
 		return new PK_MessageAccumulatorImpl<CPP_TYPENAME SCHEME_OPTIONS::HashFunction>;
 	}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~TF_ObjectImplBase() { }
-#endif
 
 protected:
 	const typename BASE::MessageEncodingInterface & GetMessageEncodingInterface() const 
@@ -616,16 +615,16 @@ template <class BASE, class SCHEME_OPTIONS, class KEY>
 class TF_ObjectImplExtRef : public TF_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~TF_ObjectImplExtRef() { }
+#endif
+
 	TF_ObjectImplExtRef(const KEY *pKey = NULL) : m_pKey(pKey) {}
 	void SetKeyPtr(const KEY *pKey) {m_pKey = pKey;}
 
 	const KEY & GetKey() const {return *m_pKey;}
 	KEY & AccessKey() {throw NotImplemented("TF_ObjectImplExtRef: cannot modify refererenced key");}
 
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~TF_ObjectImplExtRef() { }
-#endif
-
 private:
 	const KEY * m_pKey;
 };
@@ -637,13 +636,13 @@ class CRYPTOPP_NO_VTABLE TF_ObjectImpl : public TF_ObjectImplBase<BASE, SCHEME_O
 public:
 	typedef KEY_CLASS KeyClass;
 
-	const KeyClass & GetKey() const {return m_trapdoorFunction;}
-	KeyClass & AccessKey() {return m_trapdoorFunction;}
-	
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
 	virtual ~TF_ObjectImpl() { }
 #endif
 
+	const KeyClass & GetKey() const {return m_trapdoorFunction;}
+	KeyClass & AccessKey() {return m_trapdoorFunction;}
+
 private:
 	KeyClass m_trapdoorFunction;
 };
@@ -680,6 +679,7 @@ class CRYPTOPP_NO_VTABLE MaskGeneratingFunction
 {
 public:
 	virtual ~MaskGeneratingFunction() {}
+
 	//! \brief Generate and apply mask
 	//! \param hash HashTransformation derived class
 	//! \param output the destination byte array
@@ -752,6 +752,10 @@ class CRYPTOPP_NO_VTABLE DL_GroupParameters : public CryptoParameters
 public:
 	typedef T Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_GroupParameters() { }
+#endif
+
 	DL_GroupParameters() : m_validationLevel(0) {}
 
 	// CryptoMaterial
@@ -942,10 +946,6 @@ public:
 	//! \pre <tt>COUNTOF(exponents) == exponentsCount</tt>
 	virtual void SimultaneousExponentiate(Element *results, const Element &base, const Integer *exponents, unsigned int exponentsCount) const =0;
 
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_GroupParameters() { }
-#endif
-
 protected:
 	void ParametersChanged() {m_validationLevel = 0;}
 
@@ -965,6 +965,10 @@ public:
 	typedef typename GROUP_PRECOMP::Element Element;
 	typedef BASE_PRECOMP BasePrecomputation;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_GroupParametersImpl() { }
+#endif
+
 	//! \brief Retrieves the group precomputation
 	//! \return a const reference to the group precomputation
 	const DL_GroupPrecomputation<Element> & GetGroupPrecomputation() const {return m_groupPrecomputation;}
@@ -977,10 +981,6 @@ public:
 	//! \return a non-const reference to the group precomputation using a fixed base
 	DL_FixedBasePrecomputation<Element> & AccessBasePrecomputation() {return m_gpc;}
 
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_GroupParametersImpl() { }
-#endif
-	
 protected:
 	GROUP_PRECOMP m_groupPrecomputation;
 	BASE_PRECOMP m_gpc;
@@ -993,6 +993,10 @@ template <class T>
 class CRYPTOPP_NO_VTABLE DL_Key
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_Key() { }
+#endif
+
 	//! \brief Retrieves abstract group parameters
 	//! \return a const reference to the group parameters
 	virtual const DL_GroupParameters<T> & GetAbstractGroupParameters() const =0;
@@ -1010,6 +1014,10 @@ class CRYPTOPP_NO_VTABLE DL_PublicKey : public DL_Key<T>
 public:
 	typedef T Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_PublicKey() { }
+#endif
+
 	bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const
 	{
 		return GetValueHelper(this, name, valueType, pValue, &this->GetAbstractGroupParameters())
@@ -1034,10 +1042,6 @@ public:
 
 	virtual const DL_FixedBasePrecomputation<T> & GetPublicPrecomputation() const =0;
 	virtual DL_FixedBasePrecomputation<T> & AccessPublicPrecomputation() =0;
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_PublicKey() { }
-#endif
 };
 
 //! \brief Interface for Discrete Log (DL) private keys
@@ -1049,6 +1053,10 @@ class CRYPTOPP_NO_VTABLE DL_PrivateKey : public DL_Key<T>
 public:
 	typedef T Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_PrivateKey() { }
+#endif
+
 	void MakePublicKey(DL_PublicKey<T> &pub) const
 	{
 		pub.AccessAbstractGroupParameters().AssignFrom(this->GetAbstractGroupParameters());
@@ -1070,10 +1078,6 @@ public:
 
 	virtual const Integer & GetPrivateExponent() const =0;
 	virtual void SetPrivateExponent(const Integer &x) =0;
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_PrivateKey() { }
-#endif
 };
 
 template <class T>
@@ -1099,6 +1103,10 @@ class DL_KeyImpl : public PK
 public:
 	typedef GP GroupParameters;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_KeyImpl() { }
+#endif
+
 	O GetAlgorithmID() const {return GetGroupParameters().GetAlgorithmID();}
 //	void BERDecode(BufferedTransformation &bt)
 //		{PK::BERDecode(bt);}
@@ -1126,6 +1134,10 @@ class DL_PrivateKeyImpl : public DL_PrivateKey<CPP_TYPENAME GP::Element>, public
 public:
 	typedef typename GP::Element Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_PrivateKeyImpl() { }
+#endif
+
 	// GeneratableCryptoMaterial
 	bool Validate(RandomNumberGenerator &rng, unsigned int level) const
 	{
@@ -1195,6 +1207,10 @@ template <class BASE, class SIGNATURE_SCHEME>
 class DL_PrivateKey_WithSignaturePairwiseConsistencyTest : public BASE
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_PrivateKey_WithSignaturePairwiseConsistencyTest() { }
+#endif
+
 	void GenerateRandom(RandomNumberGenerator &rng, const NameValuePairs &params)
 	{
 		BASE::GenerateRandom(rng, params);
@@ -1215,6 +1231,10 @@ class DL_PublicKeyImpl : public DL_PublicKey<typename GP::Element>, public DL_Ke
 public:
 	typedef typename GP::Element Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_PublicKeyImpl() { }
+#endif
+
 	// CryptoMaterial
 	bool Validate(RandomNumberGenerator &rng, unsigned int level) const
 	{
@@ -1274,6 +1294,10 @@ template <class T>
 class CRYPTOPP_NO_VTABLE DL_ElgamalLikeSignatureAlgorithm
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_ElgamalLikeSignatureAlgorithm() { }
+#endif
+
 	virtual void Sign(const DL_GroupParameters<T> &params, const Integer &privateKey, const Integer &k, const Integer &e, Integer &r, Integer &s) const =0;
 	virtual bool Verify(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &e, const Integer &r, const Integer &s) const =0;
 	virtual Integer RecoverPresignature(const DL_GroupParameters<T> &params, const DL_PublicKey<T> &publicKey, const Integer &r, const Integer &s) const
@@ -1294,12 +1318,12 @@ class CRYPTOPP_NO_VTABLE DL_KeyAgreementAlgorithm
 public:
 	typedef T Element;
 
-	virtual Element AgreeWithEphemeralPrivateKey(const DL_GroupParameters<Element> &params, const DL_FixedBasePrecomputation<Element> &publicPrecomputation, const Integer &privateExponent) const =0;
-	virtual Element AgreeWithStaticPrivateKey(const DL_GroupParameters<Element> &params, const Element &publicElement, bool validateOtherPublicKey, const Integer &privateExponent) const =0;
-
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
 	virtual ~DL_KeyAgreementAlgorithm() { }
 #endif
+
+	virtual Element AgreeWithEphemeralPrivateKey(const DL_GroupParameters<Element> &params, const DL_FixedBasePrecomputation<Element> &publicPrecomputation, const Integer &privateExponent) const =0;
+	virtual Element AgreeWithStaticPrivateKey(const DL_GroupParameters<Element> &params, const Element &publicElement, bool validateOtherPublicKey, const Integer &privateExponent) const =0;
 };
 
 //! \brief Interface for key derivation algorithms used in DL cryptosystems
@@ -1307,19 +1331,23 @@ template <class T>
 class CRYPTOPP_NO_VTABLE DL_KeyDerivationAlgorithm
 {
 public:
-	virtual bool ParameterSupported(const char *name) const
-		{CRYPTOPP_UNUSED(name); return false;}
-	virtual void Derive(const DL_GroupParameters<T> &groupParams, byte *derivedKey, size_t derivedLength, const T &agreedElement, const T &ephemeralPublicKey, const NameValuePairs &derivationParams) const =0;
-
 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
 	virtual ~DL_KeyDerivationAlgorithm() { }
 #endif
+
+	virtual bool ParameterSupported(const char *name) const
+		{CRYPTOPP_UNUSED(name); return false;}
+	virtual void Derive(const DL_GroupParameters<T> &groupParams, byte *derivedKey, size_t derivedLength, const T &agreedElement, const T &ephemeralPublicKey, const NameValuePairs &derivationParams) const =0;
 };
 
 //! \brief Interface for symmetric encryption algorithms used in DL cryptosystems
 class CRYPTOPP_NO_VTABLE DL_SymmetricEncryptionAlgorithm
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_SymmetricEncryptionAlgorithm() { }
+#endif
+
 	virtual bool ParameterSupported(const char *name) const
 		{CRYPTOPP_UNUSED(name); return false;}
 	virtual size_t GetSymmetricKeyLength(size_t plaintextLength) const =0;
@@ -1327,13 +1355,10 @@ public:
 	virtual size_t GetMaxSymmetricPlaintextLength(size_t ciphertextLength) const =0;
 	virtual void SymmetricEncrypt(RandomNumberGenerator &rng, const byte *key, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters) const =0;
 	virtual DecodingResult SymmetricDecrypt(const byte *key, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters) const =0;
-
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_SymmetricEncryptionAlgorithm() { }
-#endif
 };
 
-//! _
+//! \brief Discrete Log (DL) base interface
+//! \tparam KI public or private key interface
 template <class KI>
 class CRYPTOPP_NO_VTABLE DL_Base
 {
@@ -1341,42 +1366,65 @@ protected:
 	typedef KI KeyInterface;
 	typedef typename KI::Element Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_Base() { }
+#endif
+
 	const DL_GroupParameters<Element> & GetAbstractGroupParameters() const {return GetKeyInterface().GetAbstractGroupParameters();}
 	DL_GroupParameters<Element> & AccessAbstractGroupParameters() {return AccessKeyInterface().AccessAbstractGroupParameters();}
 
 	virtual KeyInterface & AccessKeyInterface() =0;
 	virtual const KeyInterface & GetKeyInterface() const =0;
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_Base() { }
-#endif
 };
 
-//! _
+//! \brief Discrete Log (DL) signature scheme base implementation
+//! \tparam INTERFACE PK_Signer or PK_Verifier derived class
+//! \tparam DL_Base key base used in the scheme
+//! \details DL_SignatureSchemeBase provides common functions for signers and verifiers.
+//!   DL_Base<DL_PrivateKey> is used for signers, and DL_Base<DL_PublicKey> is used for verifiers.
 template <class INTERFACE, class KEY_INTERFACE>
 class CRYPTOPP_NO_VTABLE DL_SignatureSchemeBase : public INTERFACE, public DL_Base<KEY_INTERFACE>
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_SignatureSchemeBase() { }
+#endif
+
+	//! \brief Provides the signature length
+	//! \returns signature length, in bytes
+	//! \details SignatureLength returns the size required for <tt>r+s</tt>.
 	size_t SignatureLength() const
 	{
 		return GetSignatureAlgorithm().RLen(this->GetAbstractGroupParameters())
 			+ GetSignatureAlgorithm().SLen(this->GetAbstractGroupParameters());
 	}
+
+	//! \brief Provides the maximum recoverable length
+	//! \returns maximum recoverable length, in bytes
 	size_t MaxRecoverableLength() const 
 		{return GetMessageEncodingInterface().MaxRecoverableLength(0, GetHashIdentifier().second, GetDigestSize());}
+
+	//! \brief Provides the maximum recoverable length
+	//! \param signatureLength the size fo the signature
+	//! \returns maximum recoverable length based on signature length, in bytes
+	//! \details this function is not implemented and always returns 0.
 	size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const
 		{CRYPTOPP_UNUSED(signatureLength); assert(false); return 0;}	// TODO
 
+	//! \brief Determines if the scheme is probabilistic
+	//! \returns true if the scheme is probabilistic, false otherwise
 	bool IsProbabilistic() const 
 		{return true;}
+
+	//! \brief Determines if the scheme has non-recoverable part
+	//! \returns true if the message encoding has a non-recoverable part, false otherwise.
 	bool AllowNonrecoverablePart() const 
 		{return GetMessageEncodingInterface().AllowNonrecoverablePart();}
+
+	//! \brief Determines if the scheme allows recoverable part first
+	//! \returns true if the message encoding allows the recoverable part, false otherwise.
 	bool RecoverablePartFirst() const 
 		{return GetMessageEncodingInterface().RecoverablePartFirst();}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_SignatureSchemeBase() { }
-#endif
 
 protected:
 	size_t MessageRepresentativeLength() const {return BitsToBytes(MessageRepresentativeBitLength());}
@@ -1388,12 +1436,21 @@ protected:
 	virtual size_t GetDigestSize() const =0;
 };
 
-//! _
+//! \brief Discrete Log (DL) signature scheme signer base implementation
+//! \tparam T
 template <class T>
 class CRYPTOPP_NO_VTABLE DL_SignerBase : public DL_SignatureSchemeBase<PK_Signer, DL_PrivateKey<T> >
 {
 public:
-	// for validation testing
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_SignerBase() { }
+#endif
+
+	//! \brief Testing interface
+	//! \param k Integer
+	//! \param e Integer
+	//! \param r Integer
+	//! \param s Integer
 	void RawSign(const Integer &k, const Integer &e, Integer &r, Integer &s) const
 	{
 		const DL_ElgamalLikeSignatureAlgorithm<T> &alg = this->GetSignatureAlgorithm();
@@ -1459,10 +1516,6 @@ public:
 
 		return this->SignatureLength();
 	}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_SignerBase() { }
-#endif
 
 protected:
 	void RestartMessageAccumulator(RandomNumberGenerator &rng, PK_MessageAccumulatorBase &ma) const
@@ -1487,6 +1540,10 @@ template <class T>
 class CRYPTOPP_NO_VTABLE DL_VerifierBase : public DL_SignatureSchemeBase<PK_Verifier, DL_PublicKey<T> >
 {
 public:
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_VerifierBase() { }
+#endif
+
 	void InputSignature(PK_MessageAccumulator &messageAccumulator, const byte *signature, size_t signatureLength) const
 	{
 		CRYPTOPP_UNUSED(signature); CRYPTOPP_UNUSED(signatureLength); 
@@ -1549,19 +1606,21 @@ public:
 			ma.m_semisignature, ma.m_semisignature.size(),
 			recoveredMessage);
 	}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_VerifierBase() { }
-#endif
 };
 
-//! _
+//! \brief Discrete Log (DL) cryptosystem base implementation
+//! \tparam PK field element type
+//! \tparam KI public or private key interface
 template <class PK, class KI>
 class CRYPTOPP_NO_VTABLE DL_CryptoSystemBase : public PK, public DL_Base<KI>
 {
 public:
 	typedef typename DL_Base<KI>::Element Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_CryptoSystemBase() { }
+#endif
+
 	size_t MaxPlaintextLength(size_t ciphertextLength) const
 	{
 		unsigned int minLen = this->GetAbstractGroupParameters().GetEncodedElementSize(true);
@@ -1576,10 +1635,6 @@ public:
 
 	bool ParameterSupported(const char *name) const
 		{return GetKeyDerivationAlgorithm().ParameterSupported(name) || GetSymmetricEncryptionAlgorithm().ParameterSupported(name);}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_CryptoSystemBase() { }
-#endif
 
 protected:
 	virtual const DL_KeyAgreementAlgorithm<Element> & GetKeyAgreementAlgorithm() const =0;
@@ -1587,13 +1642,18 @@ protected:
 	virtual const DL_SymmetricEncryptionAlgorithm & GetSymmetricEncryptionAlgorithm() const =0;
 };
 
-//! _
+//! \brief Discrete Log (DL) decryptor base implementation
+//! \tparam T field element type
 template <class T>
 class CRYPTOPP_NO_VTABLE DL_DecryptorBase : public DL_CryptoSystemBase<PK_Decryptor, DL_PrivateKey<T> >
 {
 public:
 	typedef T Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_DecryptorBase() { }
+#endif
+
 	DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const
 	{
 		try
@@ -1622,19 +1682,20 @@ public:
 			return DecodingResult();
 		}
 	}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_DecryptorBase() { }
-#endif
 };
 
-//! _
+//! \brief Discrete Log (DL) encryptor base implementation
+//! \tparam T field element type
 template <class T>
 class CRYPTOPP_NO_VTABLE DL_EncryptorBase : public DL_CryptoSystemBase<PK_Encryptor, DL_PublicKey<T> >
 {
 public:
 	typedef T Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_EncryptorBase() { }
+#endif
+
 	void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs &parameters = g_nullNameValuePairs) const
 	{
 		const DL_KeyAgreementAlgorithm<T> &agreeAlg = this->GetKeyAgreementAlgorithm();
@@ -1656,13 +1717,11 @@ public:
 
 		encAlg.SymmetricEncrypt(rng, derivedKey, plaintext, plaintextLength, ciphertext, parameters);
 	}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_EncryptorBase() { }
-#endif
 };
 
-//! _
+//! \brief Discrete Log (DL) scheme options
+//! \tparam T1 algorithm information
+//! \tparam T2 group paramters for the scheme
 template <class T1, class T2>
 struct DL_SchemeOptionsBase
 {
@@ -1671,7 +1730,9 @@ struct DL_SchemeOptionsBase
 	typedef typename GroupParameters::Element Element;
 };
 
-//! _
+//! \brief Discrete Log (DL) key options
+//! \tparam T1 algorithm information
+//! \tparam T2 keys used in the scheme
 template <class T1, class T2>
 struct DL_KeyedSchemeOptions : public DL_SchemeOptionsBase<T1, typename T2::PublicKey::GroupParameters>
 {
@@ -1680,7 +1741,12 @@ struct DL_KeyedSchemeOptions : public DL_SchemeOptionsBase<T1, typename T2::Publ
 	typedef typename Keys::PublicKey PublicKey;
 };
 
-//! _
+//! \brief Discrete Log (DL) signature scheme options
+//! \tparam T1 algorithm information
+//! \tparam T2 keys used in the scheme
+//! \tparam T3 signature algorithm
+//! \tparam T4 message encoding method
+//! \tparam T5 hash function
 template <class T1, class T2, class T3, class T4, class T5>
 struct DL_SignatureSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>
 {
@@ -1689,7 +1755,12 @@ struct DL_SignatureSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>
 	typedef T5 HashFunction;
 };
 
-//! _
+//! \brief Discrete Log (DL) crypto scheme options
+//! \tparam T1 algorithm information
+//! \tparam T2 keys used in the scheme
+//! \tparam T3 key agreement algorithm
+//! \tparam T4 key derivation algorithm
+//! \tparam T5 symmetric encryption algorithm
 template <class T1, class T2, class T3, class T4, class T5>
 struct DL_CryptoSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>
 {
@@ -1698,7 +1769,10 @@ struct DL_CryptoSchemeOptions : public DL_KeyedSchemeOptions<T1, T2>
 	typedef T5 SymmetricEncryptionAlgorithm;
 };
 
-//! _
+//! \brief Discrete Log (DL) base object implementation
+//! \tparam BASE TODO
+//! \tparam SCHEME_OPTIONS options for the scheme
+//! \tparam KEY key used in the scheme
 template <class BASE, class SCHEME_OPTIONS, class KEY>
 class CRYPTOPP_NO_VTABLE DL_ObjectImplBase : public AlgorithmImpl<BASE, typename SCHEME_OPTIONS::AlgorithmInfo>
 {
@@ -1706,16 +1780,16 @@ public:
 	typedef SCHEME_OPTIONS SchemeOptions;
 	typedef typename KEY::Element Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_ObjectImplBase() { }
+#endif
+
 	PrivateKey & AccessPrivateKey() {return m_key;}
 	PublicKey & AccessPublicKey() {return m_key;}
 
 	// KeyAccessor
 	const KEY & GetKey() const {return m_key;}
 	KEY & AccessKey() {return m_key;}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_ObjectImplBase() { }
-#endif
 
 protected:
 	typename BASE::KeyInterface & AccessKeyInterface() {return m_key;}
@@ -1737,7 +1811,10 @@ private:
 	KEY m_key;
 };
 
-//! _
+//! \brief Discrete Log (DL) object implementation
+//! \tparam BASE TODO
+//! \tparam SCHEME_OPTIONS options for the scheme
+//! \tparam KEY key used in the scheme
 template <class BASE, class SCHEME_OPTIONS, class KEY>
 class CRYPTOPP_NO_VTABLE DL_ObjectImpl : public DL_ObjectImplBase<BASE, SCHEME_OPTIONS, KEY>
 {
@@ -1763,7 +1840,8 @@ protected:
 		{return Singleton<CPP_TYPENAME SCHEME_OPTIONS::MessageEncodingMethod>().Ref();}
 };
 
-//! _
+//! \brief Discrete Log (DL) signer implementation
+//! \tparam SCHEME_OPTIONS options for the scheme
 template <class SCHEME_OPTIONS>
 class DL_SignerImpl : public DL_ObjectImpl<DL_SignerBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>
 {
@@ -1776,7 +1854,8 @@ public:
 	}
 };
 
-//! _
+//! \brief Discrete Log (DL) verifier implementation
+//! \tparam SCHEME_OPTIONS options for the scheme
 template <class SCHEME_OPTIONS>
 class DL_VerifierImpl : public DL_ObjectImpl<DL_VerifierBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>
 {
@@ -1787,13 +1866,15 @@ public:
 	}
 };
 
-//! _
+//! \brief Discrete Log (DL) encryptor implementation
+//! \tparam SCHEME_OPTIONS options for the scheme
 template <class SCHEME_OPTIONS>
 class DL_EncryptorImpl : public DL_ObjectImpl<DL_EncryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PublicKey>
 {
 };
 
-//! _
+//! \brief Discrete Log (DL) decryptor implementation
+//! \tparam SCHEME_OPTIONS options for the scheme
 template <class SCHEME_OPTIONS>
 class DL_DecryptorImpl : public DL_ObjectImpl<DL_DecryptorBase<typename SCHEME_OPTIONS::Element>, SCHEME_OPTIONS, typename SCHEME_OPTIONS::PrivateKey>
 {
@@ -1801,13 +1882,18 @@ class DL_DecryptorImpl : public DL_ObjectImpl<DL_DecryptorBase<typename SCHEME_O
 
 // ********************************************************
 
-//! _
+//! \brief Discrete Log (DL) simple key agreement base implementation
+//! \tparam T class or type
 template <class T>
 class CRYPTOPP_NO_VTABLE DL_SimpleKeyAgreementDomainBase : public SimpleKeyAgreementDomain
 {
 public:
 	typedef T Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_SimpleKeyAgreementDomainBase() { }
+#endif
+
 	CryptoParameters & AccessCryptoParameters() {return AccessAbstractGroupParameters();}
 	unsigned int AgreedValueLength() const {return GetAbstractGroupParameters().GetEncodedElementSize(false);}
 	unsigned int PrivateKeyLength() const {return GetAbstractGroupParameters().GetSubgroupOrder().ByteCount();}
@@ -1847,11 +1933,9 @@ public:
 		return true;
 	}
 
+	//! \brief Retrieves a reference to the group generator
+	//! \returns const reference to the group generator
 	const Element &GetGenerator() const {return GetAbstractGroupParameters().GetSubgroupGenerator();}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_SimpleKeyAgreementDomainBase() { }
-#endif
 
 protected:
 	virtual const DL_KeyAgreementAlgorithm<Element> & GetKeyAgreementAlgorithm() const =0;
@@ -1886,6 +1970,10 @@ class DL_KeyAgreementAlgorithm_DH : public DL_KeyAgreementAlgorithm<ELEMENT>
 public:
 	typedef ELEMENT Element;
 
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+	virtual ~DL_KeyAgreementAlgorithm_DH() {}
+#endif
+
 	static const char * CRYPTOPP_API StaticAlgorithmName()
 		{return COFACTOR_OPTION::ToEnum() == INCOMPATIBLE_COFACTOR_MULTIPLICTION ? "DHC" : "DH";}
 
@@ -1929,15 +2017,11 @@ public:
 			}
 		}
 	}
-	
-#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
-	virtual ~DL_KeyAgreementAlgorithm_DH() {}
-#endif
 };
 
 // ********************************************************
 
-//! \details Template implementing constructors for public key algorithm classes
+//! \brief Template implementing constructors for public key algorithm classes
 template <class BASE>
 class CRYPTOPP_NO_VTABLE PK_FinalTemplate : public BASE
 {
@@ -2057,10 +2141,13 @@ struct EncryptionStandard {};
 //!   Not all standards apply to all algorithms.
 struct SignatureStandard {};
 
+//! \brief Trapdoor Function (TF) encryption scheme
+//! \tparam STANDARD standard
+//! \tparam KEYS keys used in the encryption scheme
+//! \tparam ALG_INFO algorithm information
 template <class STANDARD, class KEYS, class ALG_INFO>
 class TF_ES;
 
-//! \brief Trapdoor Function Based Encryption Scheme
 template <class STANDARD, class KEYS, class ALG_INFO = TF_ES<STANDARD, KEYS, int> >
 class TF_ES : public KEYS
 {
@@ -2079,10 +2166,15 @@ public:
 	typedef PK_FinalTemplate<TF_EncryptorImpl<SchemeOptions> > Encryptor;
 };
 
+//! \class TF_SS
+//! \brief Trapdoor Function (TF) Signature Scheme
+//! \tparam STANDARD standard
+//! \tparam H hash function
+//! \tparam KEYS keys used in the signature scheme
+//! \tparam ALG_INFO algorithm information
 template <class STANDARD, class H, class KEYS, class ALG_INFO>	// VC60 workaround: doesn't work if KEYS is first parameter
 class TF_SS;
 
-//! \brief Trapdoor Function Based Signature Scheme
 template <class STANDARD, class H, class KEYS, class ALG_INFO = TF_SS<STANDARD, H, KEYS, int> >	// VC60 workaround: doesn't work if KEYS is first parameter
 class TF_SS : public KEYS
 {
@@ -2100,10 +2192,16 @@ public:
 	typedef PK_FinalTemplate<TF_VerifierImpl<SchemeOptions> > Verifier;
 };
 
+//! \class DL_SS
+//! \brief Discrete Log (DL) signature scheme
+//! \tparam KEYS keys used in the signature scheme
+//! \tparam SA signature algorithm
+//! \tparam MEM message encoding method
+//! \tparam H hash function
+//! \tparam ALG_INFO algorithm information
 template <class KEYS, class SA, class MEM, class H, class ALG_INFO>
 class DL_SS;
 
-//! \brief Discrete Log Based Signature Scheme
 template <class KEYS, class SA, class MEM, class H, class ALG_INFO = DL_SS<KEYS, SA, MEM, H, int> >
 class DL_SS : public KEYS
 {
@@ -2118,7 +2216,12 @@ public:
 	typedef PK_FinalTemplate<DL_VerifierImpl<SchemeOptions> > Verifier;
 };
 
-//! \brief Discrete Log Based Encryption Scheme
+//! \brief Discrete Log (DL) encryption scheme
+//! \tparam KEYS keys used in the encryption scheme
+//! \tparam AA key agreement algorithm
+//! \tparam DA key derivation algorithm
+//! \tparam EA encryption algorithm
+//! \tparam ALG_INFO algorithm information
 template <class KEYS, class AA, class DA, class EA, class ALG_INFO>
 class DL_ES : public KEYS
 {