diff --git a/algebra.h b/algebra.h
index fed8e85f..9326ec6f 100644
--- a/algebra.h
+++ b/algebra.h
@@ -294,7 +294,7 @@ public:
 	/// \brief Calculates the greatest common denominator in the ring
 	/// \param a the first element
 	/// \param b the second element
-	/// \return the the greatest common denominator of a and b.
+	/// \return the greatest common denominator of a and b.
 	virtual const Element& Gcd(const Element &a, const Element &b) const;
 
 protected:
diff --git a/arm_simd.h b/arm_simd.h
index c2ccdacd..c7f2127e 100644
--- a/arm_simd.h
+++ b/arm_simd.h
@@ -28,7 +28,7 @@
 ///  The <tt>0x00</tt> indicates the low 64-bits of <tt>a</tt> and <tt>b</tt>
 ///  are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and
+///  is MSB and numbered 127, while the rightmost bit is LSB and
 ///  numbered 0.
 /// \since Crypto++ 8.0
 inline uint64x2_t PMULL_00(const uint64x2_t a, const uint64x2_t b)
@@ -58,7 +58,7 @@ inline uint64x2_t PMULL_00(const uint64x2_t a, const uint64x2_t b)
 ///  The <tt>0x01</tt> indicates the low 64-bits of <tt>a</tt> and high
 ///  64-bits of <tt>b</tt> are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and
+///  is MSB and numbered 127, while the rightmost bit is LSB and
 ///  numbered 0.
 /// \since Crypto++ 8.0
 inline uint64x2_t PMULL_01(const uint64x2_t a, const uint64x2_t b)
@@ -88,7 +88,7 @@ inline uint64x2_t PMULL_01(const uint64x2_t a, const uint64x2_t b)
 ///  The <tt>0x10</tt> indicates the high 64-bits of <tt>a</tt> and low
 ///  64-bits of <tt>b</tt> are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and
+///  is MSB and numbered 127, while the rightmost bit is LSB and
 ///  numbered 0.
 /// \since Crypto++ 8.0
 inline uint64x2_t PMULL_10(const uint64x2_t a, const uint64x2_t b)
@@ -118,7 +118,7 @@ inline uint64x2_t PMULL_10(const uint64x2_t a, const uint64x2_t b)
 ///  The <tt>0x11</tt> indicates the high 64-bits of <tt>a</tt> and <tt>b</tt>
 ///  are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and
+///  is MSB and numbered 127, while the rightmost bit is LSB and
 ///  numbered 0.
 /// \since Crypto++ 8.0
 inline uint64x2_t PMULL_11(const uint64x2_t a, const uint64x2_t b)
diff --git a/cryptlib.h b/cryptlib.h
index d86931a7..ba957f1f 100644
--- a/cryptlib.h
+++ b/cryptlib.h
@@ -1340,7 +1340,7 @@ public:
 	/// \return the maximum length of encrypted data
 	virtual lword MaxMessageLength() const =0;
 
-	/// \brief Provides the the maximum length of AAD
+	/// \brief Provides the maximum length of AAD
 	/// \return the maximum length of AAD that can be input after the encrypted data
 	virtual lword MaxFooterLength() const {return 0;}
 
@@ -2725,7 +2725,7 @@ public:
 	/// \param parameters a set of NameValuePairs to initialize this object
 	/// \return the result of the decryption operation
 	/// \details If DecodingResult::isValidCoding is true, then DecodingResult::messageLength
-	///  is valid and holds the the actual length of the plaintext recovered. The result is undefined
+	///  is valid and holds the actual length of the plaintext recovered. The result is undefined
 	///  if decryption failed. If DecodingResult::isValidCoding is false, then DecodingResult::messageLength
 	///  is undefined.
 	/// \pre <tt>COUNTOF(plaintext) == MaxPlaintextLength(ciphertextLength)</tt> ensures the output
@@ -2751,7 +2751,7 @@ public:
 	/// \param parameters a set of NameValuePairs to initialize this object
 	/// \return the result of the decryption operation
 	/// \details If DecodingResult::isValidCoding is true, then DecodingResult::messageLength
-	///  is valid and holds the the actual length of the plaintext recovered. The result is undefined
+	///  is valid and holds the actual length of the plaintext recovered. The result is undefined
 	///  if decryption failed. If DecodingResult::isValidCoding is false, then DecodingResult::messageLength
 	///  is undefined.
 	/// \pre <tt>COUNTOF(plaintext) == MaxPlaintextLength(ciphertextLength)</tt> ensures the output
diff --git a/ec2n.h b/ec2n.h
index b05377bb..1da17842 100644
--- a/ec2n.h
+++ b/ec2n.h
@@ -44,7 +44,7 @@ public:
 
 	/// \brief Construct an EC2N from BER encoded parameters
 	/// \param bt BufferedTransformation derived object
-	/// \details This constructor will decode and extract the the fields fieldID and curve of the sequence ECParameters
+	/// \details This constructor will decode and extract the fields fieldID and curve of the sequence ECParameters
 	EC2N(BufferedTransformation &bt);
 
 	/// \brief Encode the fields fieldID and curve of the sequence ECParameters
diff --git a/ecp.h b/ecp.h
index a5bdcd94..1dc02ab0 100644
--- a/ecp.h
+++ b/ecp.h
@@ -54,7 +54,7 @@ public:
 
 	/// \brief Construct an ECP from BER encoded parameters
 	/// \param bt BufferedTransformation derived object
-	/// \details This constructor will decode and extract the the fields
+	/// \details This constructor will decode and extract the fields
 	///  fieldID and curve of the sequence ECParameters
 	ECP(BufferedTransformation &bt);
 
diff --git a/eprecomp.h b/eprecomp.h
index d91d41d3..737a1569 100644
--- a/eprecomp.h
+++ b/eprecomp.h
@@ -90,14 +90,14 @@ public:
 	virtual void Precompute(const DL_GroupPrecomputation<Element> &group, unsigned int maxExpBits, unsigned int storage) =0;
 
 	/// \brief Retrieve previously saved precomputation
-	/// \param group the the group
+	/// \param group the group
 	/// \param storedPrecomputation BufferedTransformation with the saved precomputation
 	/// \throw NotImplemented
 	/// \sa SupportsPrecomputation(), Precompute()
 	virtual void Load(const DL_GroupPrecomputation<Element> &group, BufferedTransformation &storedPrecomputation) =0;
 
 	/// \brief Save precomputation for later use
-	/// \param group the the group
+	/// \param group the group
 	/// \param storedPrecomputation BufferedTransformation to write the precomputation
 	/// \throw NotImplemented
 	/// \sa SupportsPrecomputation(), Precompute()
diff --git a/nbtheory.h b/nbtheory.h
index 22bafa3c..2b29c4db 100644
--- a/nbtheory.h
+++ b/nbtheory.h
@@ -181,7 +181,7 @@ CRYPTOPP_DLL Integer CRYPTOPP_API CRT(const Integer &xp, const Integer &p, const
 /// \brief Calculate the Jacobi symbol
 /// \param a the first term
 /// \param b the second term
-/// \return the the Jacobi symbol.
+/// \return the Jacobi symbol.
 /// \details Jacobi symbols are calculated using the following rules:
 ///  -# if <tt>b</tt> is prime, then <tt>Jacobi(a, b)</tt>, then return 0
 ///  -# if <tt>a%b</tt>==0 AND <tt>a</tt> is quadratic residue <tt>mod b</tt>, then return 1
@@ -305,7 +305,7 @@ public:
 	const Integer& SubPrime() const {return q;}
 
 	/// \brief Retrieve the generator
-	/// \return Generator() returns the the generator g.
+	/// \return Generator() returns the generator g.
 	const Integer& Generator() const {return g;}
 
 private:
diff --git a/ossig.h b/ossig.h
index 3b48af5d..ce9789b7 100644
--- a/ossig.h
+++ b/ossig.h
@@ -29,7 +29,7 @@ extern "C" {
 /// \brief Null signal handler function
 /// \param unused the signal number
 /// \details NullSignalHandler is provided as a stand alone function with external "C" linkage
-///  and not a static member function due to the the member function's implicit
+///  and not a static member function due to the member function's implicit
 ///  external "C++" linkage.
 /// \sa SignalHandler, SignalHandlerFn
 extern "C" {
diff --git a/ppc_simd.h b/ppc_simd.h
index 65008066..84085618 100644
--- a/ppc_simd.h
+++ b/ppc_simd.h
@@ -2510,7 +2510,7 @@ inline uint64x2_p VecPolyMultiply(const uint64x2_p& a, const uint64x2_p& b)
 ///  The <tt>0x00</tt> indicates the low 64-bits of <tt>a</tt> and <tt>b</tt>
 ///  are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and numbered 0.
+///  is MSB and numbered 127, while the rightmost bit is LSB and numbered 0.
 /// \par Wraps
 ///  __vpmsumd, __builtin_altivec_crypto_vpmsumd and __builtin_crypto_vpmsumd.
 /// \since Crypto++ 8.0
@@ -2532,7 +2532,7 @@ inline uint64x2_p VecIntelMultiply00(const uint64x2_p& a, const uint64x2_p& b)
 ///  The <tt>0x01</tt> indicates the low 64-bits of <tt>a</tt> and high
 ///  64-bits of <tt>b</tt> are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and numbered 0.
+///  is MSB and numbered 127, while the rightmost bit is LSB and numbered 0.
 /// \par Wraps
 ///  __vpmsumd, __builtin_altivec_crypto_vpmsumd and __builtin_crypto_vpmsumd.
 /// \since Crypto++ 8.0
@@ -2554,7 +2554,7 @@ inline uint64x2_p VecIntelMultiply01(const uint64x2_p& a, const uint64x2_p& b)
 ///  The <tt>0x10</tt> indicates the high 64-bits of <tt>a</tt> and low
 ///  64-bits of <tt>b</tt> are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and numbered 0.
+///  is MSB and numbered 127, while the rightmost bit is LSB and numbered 0.
 /// \par Wraps
 ///  __vpmsumd, __builtin_altivec_crypto_vpmsumd and __builtin_crypto_vpmsumd.
 /// \since Crypto++ 8.0
@@ -2576,7 +2576,7 @@ inline uint64x2_p VecIntelMultiply10(const uint64x2_p& a, const uint64x2_p& b)
 ///  The <tt>0x11</tt> indicates the high 64-bits of <tt>a</tt> and <tt>b</tt>
 ///  are multiplied.
 /// \note An Intel XMM register is composed of 128-bits. The leftmost bit
-///  is MSB and numbered 127, while the the rightmost bit is LSB and numbered 0.
+///  is MSB and numbered 127, while the rightmost bit is LSB and numbered 0.
 /// \par Wraps
 ///  __vpmsumd, __builtin_altivec_crypto_vpmsumd and __builtin_crypto_vpmsumd.
 /// \since Crypto++ 8.0
diff --git a/pssr.h b/pssr.h
index 7122549d..ab34d899 100644
--- a/pssr.h
+++ b/pssr.h
@@ -66,8 +66,8 @@ template<> class PSSR_MEM_BaseWithHashId<false> : public PSSR_MEM_Base {};
 /// \tparam SALT_LEN length of the salt
 /// \tparam MIN_PAD_LEN minimum length of the pad
 /// \tparam USE_HASH_ID flag indicating whether the HashId is used
-/// \details If ALLOW_RECOVERY is true, the the signature scheme provides message recovery. If
-///  ALLOW_RECOVERY is false, the the signature scheme is appendix, and the message must be
+/// \details If ALLOW_RECOVERY is true, the signature scheme provides message recovery. If
+///  ALLOW_RECOVERY is false, the signature scheme is appendix, and the message must be
 ///  provided during verification.
 /// \since Crypto++ 2.1
 template <bool ALLOW_RECOVERY, class MGF=P1363_MGF1, int SALT_LEN=-1, int MIN_PAD_LEN=0, bool USE_HASH_ID=false>
diff --git a/pubkey.h b/pubkey.h
index b959cd00..ca72bd19 100644
--- a/pubkey.h
+++ b/pubkey.h
@@ -87,7 +87,7 @@ public:
 	/// \details The default implementation returns <tt>PreimageBound() - 1</tt>.
 	virtual Integer MaxPreimage() const {return --PreimageBound();}
 	/// \brief Returns the maximum size of a message after the trapdoor function is applied bound to a public key
-	/// \return the the maximum size of a message after the trapdoor function is applied bound to a public key
+	/// \return the maximum size of a message after the trapdoor function is applied bound to a public key
 	/// \details The default implementation returns <tt>ImageBound() - 1</tt>.
 	virtual Integer MaxImage() const {return --ImageBound();}
 };
@@ -692,7 +692,7 @@ public:
 	/// \brief Generate and apply mask
 	/// \param hash HashTransformation derived class
 	/// \param output the destination byte array
-	/// \param outputLength the size fo the the destination byte array
+	/// \param outputLength the size fo the destination byte array
 	/// \param input the message to hash
 	/// \param inputLength the size of the message
 	/// \param mask flag indicating whether to apply the mask
@@ -703,7 +703,7 @@ public:
 /// \brief P1363 mask generation function
 /// \param hash HashTransformation derived class
 /// \param output the destination byte array
-/// \param outputLength the size fo the the destination byte array
+/// \param outputLength the size fo the destination byte array
 /// \param input the message to hash
 /// \param inputLength the size of the message
 /// \param derivationParams additional derivation parameters
@@ -727,7 +727,7 @@ public:
 	/// \brief P1363 mask generation function
 	/// \param hash HashTransformation derived class
 	/// \param output the destination byte array
-	/// \param outputLength the size fo the the destination byte array
+	/// \param outputLength the size fo the destination byte array
 	/// \param input the message to hash
 	/// \param inputLength the size of the message
 	/// \param mask flag indicating whether to apply the mask
@@ -751,7 +751,7 @@ class P1363_KDF2
 public:
 	/// \brief P1363 key derivation function
 	/// \param output the destination byte array
-	/// \param outputLength the size fo the the destination byte array
+	/// \param outputLength the size fo the destination byte array
 	/// \param input the message to hash
 	/// \param inputLength the size of the message
 	/// \param derivationParams additional derivation parameters
diff --git a/rdrand.h b/rdrand.h
index 93614a62..11d29ca9 100644
--- a/rdrand.h
+++ b/rdrand.h
@@ -20,7 +20,7 @@
 //   GenerateBlock unconditionally retries and always fulfills the request.
 
 // Throughput varies wildly depending on processor and manufacturer. A Core i5 or
-//   Core i7 RDRAND can generate at over 200 MiB/s. It is below the theroetical
+//   Core i7 RDRAND can generate at over 200 MiB/s. It is below theroetical
 //   maximum, but it takes about 5 instructions to generate, retry and store a
 //   result. A low-end Celeron may perform RDRAND at about 7 MiB/s. RDSEED
 //   performs at about 1/4 to 1/2 the rate of RDRAND. AMD RDRAND performed poorly