diff --git a/include/primesieve/PrimeGenerator.hpp b/include/primesieve/PrimeGenerator.hpp
index 99d200f3b..31f0ce100 100644
--- a/include/primesieve/PrimeGenerator.hpp
+++ b/include/primesieve/PrimeGenerator.hpp
@@ -1,10 +1,10 @@
 ///
-/// @file  PrimeGenerator.hpp
-///        Generates the primes inside [start, stop] and stores them
-///        in a vector. After the primes have been stored in the
-///        vector primesieve::iterator iterates over the vector and
-///        returns the primes. When there are no more primes left in
-///        the vector PrimeGenerator generates new primes.
+/// @file   PrimeGenerator.hpp
+/// @brief  Generates the primes inside [start, stop] and stores them
+///         in a vector. After the primes have been stored in the
+///         vector primesieve::iterator iterates over the vector and
+///         returns the primes. When there are no more primes left in
+///         the vector PrimeGenerator generates new primes.
 ///
 /// Copyright (C) 2023 Kim Walisch, <kim.walisch@gmail.com>
 ///
diff --git a/include/primesieve/intrinsics.hpp b/include/primesieve/intrinsics.hpp
index cf6b06b42..9dc9cb14d 100644
--- a/include/primesieve/intrinsics.hpp
+++ b/include/primesieve/intrinsics.hpp
@@ -1,6 +1,6 @@
 ///
-/// @file  intrinsics.hpp
-/// @brief Wrappers for compiler intrinsics.
+/// @file   intrinsics.hpp
+/// @brief  Wrappers for compiler intrinsics.
 ///
 /// Copyright (C) 2022 Kim Walisch, <kim.walisch@gmail.com>
 ///
diff --git a/src/MemoryPool.cpp b/src/MemoryPool.cpp
index 91afeb87c..a84b25b73 100644
--- a/src/MemoryPool.cpp
+++ b/src/MemoryPool.cpp
@@ -1,14 +1,14 @@
 ///
-/// @file  MemoryPool.cpp
-///        EratMedium and EratBig may use millions of buckets for
-///        storing the sieving primes that are required to cross off
-///        multiples. As many memory allocations/deallocations are
-///        bad for performance the MemoryPool initially allocates a
-///        large number of buckets (using a single memory allocation)
-///        and puts the buckets into its stock. The MemoryPool can
-///        then serve buckets to EratMedium and EratBig without
-///        doing any memory allocation as long as the MemoryPool's
-///        stock is not empty.
+/// @file   MemoryPool.cpp
+/// @brief  EratMedium and EratBig may use millions of buckets for
+///         storing the sieving primes that are required to cross off
+///         multiples. As many memory allocations/deallocations are
+///         bad for performance the MemoryPool initially allocates a
+///         large number of buckets (using a single memory allocation)
+///         and puts the buckets into its stock. The MemoryPool can
+///         then serve buckets to EratMedium and EratBig without
+///         doing any memory allocation as long as the MemoryPool's
+///         stock is not empty.
 ///
 /// Copyright (C) 2023 Kim Walisch, <kim.walisch@gmail.com>
 ///
diff --git a/src/RiemannR.cpp b/src/RiemannR.cpp
index ed8a7f980..3002fe1ae 100644
--- a/src/RiemannR.cpp
+++ b/src/RiemannR.cpp
@@ -1,17 +1,17 @@
 ///
-/// @file  RiemannR.cpp
-///        This file contains an implementation of the Riemann R
-///        function which is a very accurate approximation of PrimePi(x).
-///        The accuracy of this implementation depends on width of the
-///        long double type. If the long double type has 80 bits (e.g.
-///        Linux) then RiemannR(x) is accurate up to 10^19, if the long
-///        double type has 64 bits (e.g. MSVC & macOS) then RiemannR(x)
-///        is accurate up to 10^15. This implementation could be made
-///        more accurate using the non standard __float128 type, but for
-///        primesieve's purpose speed is more important than accuracy.
+/// @file   RiemannR.cpp
+/// @brief  This file contains an implementation of the Riemann R
+///         function which is a very accurate approximation of PrimePi(x).
+///         The accuracy of this implementation depends on width of the
+///         long double type. If the long double type has 80 bits (e.g.
+///         Linux) then RiemannR(x) is accurate up to 10^19, if the long
+///         double type has 64 bits (e.g. MSVC & macOS) then RiemannR(x)
+///         is accurate up to 10^15. This implementation could be made
+///         more accurate using the non standard __float128 type, but for
+///         primesieve's purpose speed is more important than accuracy.
 ///
-///        More details about this Riemann R function implementation:
-///        https://github.com/kimwalisch/primesieve/pull/144
+///         More details about this Riemann R function implementation:
+///         https://github.com/kimwalisch/primesieve/pull/144
 ///
 /// Copyright (C) 2024 Kim Walisch, <kim.walisch@gmail.com>
 /// Copyright (C) 2024 @nipzu, https://github.com/nipzu