From fe0c2b8517e17b30f10c24793112ac6817bca214 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 1 May 2020 23:12:38 -0400
Subject: [PATCH 001/290] compute factorial of arbitrarily any number

---
 others/large_factorial.cpp | 128 +++++++++++++++++++++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 others/large_factorial.cpp

diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
new file mode 100644
index 000000000..ef9b68feb
--- /dev/null
+++ b/others/large_factorial.cpp
@@ -0,0 +1,128 @@
+#include <iostream>
+#include <chrono>
+#include <vector>
+
+using namespace std;
+
+/**
+ * Store large unsigned numbers as a C++ vector
+ * The class provides convenience functions to add a
+ * digit to the number, perform multiplication of
+ * large number with long unsigned integers.
+ **/
+class large_number
+{
+public:
+    large_number() /**< initializer */
+    {
+        _digits.push_back(1);
+    }
+
+    /**
+     * add a digit to the large number
+     **/
+    void add_digit(unsigned int value)
+    {
+        if (value > 9)
+        {
+            fprintf(stderr, "digit > 9!!\n");
+            exit(EXIT_FAILURE);
+        }
+
+        _digits.push_back(value);
+    }
+
+    /**
+     * Get number of digits in the number
+     **/
+    const size_t num_digits() const
+    {
+        return _digits.size();
+    }
+
+    /**
+     * operator over load to access the
+     * i^th digit conveniently and also
+     * assign value to it
+     **/
+    unsigned char &operator[](size_t n)
+    {
+        return this->_digits[n];
+    }
+
+    /**
+     * multiply large number with another integer and
+     * store the result in the same large number
+     **/
+    void multiply(const unsigned long n)
+    {
+        size_t i;
+        unsigned long long carry = 0, temp;
+        for (i = 0; i < this->num_digits(); i++)
+        {
+            temp = (*this)[i] * n;
+            temp += carry;
+            if (temp < 10)
+                carry = 0;
+            else
+            {
+                carry = temp / 10;
+                temp = temp % 10;
+            }
+            (*this)[i] = temp;
+        }
+
+        while (carry != 0)
+        {
+            this->add_digit(carry % 10);
+            carry /= 10;
+        }
+    };
+
+    /**
+     * print the large number
+     **/
+    void print()
+    {
+        for (size_t i = num_digits(); i > 0; i--)
+            putchar(_digits[i - 1] + '0');
+    };
+
+private:
+    vector<unsigned char> _digits; /**< where individual digits are stored */
+};
+
+/**
+ * Main program
+ **/
+int main(int argc, char *argv[])
+{
+    int number, i;
+
+    //Asks for the number/position of term in Fibonnacci sequence
+    if (argc == 2)
+        number = atoi(argv[1]);
+    else
+    {
+        printf("Enter the value of n(n starts from 0 ): ");
+        scanf("%d", &number);
+    }
+
+    large_number result;
+
+    auto start_time = chrono::high_resolution_clock::now();
+    for (i = 2; i <= number; i++)
+        /* Multiply every number from 2 thru N */
+        result.multiply(i);
+    auto end_time = chrono::high_resolution_clock::now();
+    chrono::duration<double> time_taken = end_time - start_time;
+
+    cout << number << "! = ";
+    result.print();
+    cout << endl
+         << "Number of digits: " << result.num_digits() << endl
+         << "Time taken: " << time_taken.count() << " s"
+         << endl;
+
+    return 0;
+}

From 70cd195f307c3e68e0779a9a0b95fd950f800489 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 1 May 2020 23:31:39 -0400
Subject: [PATCH 002/290] large_factorial.cpp: added tests

---
 others/large_factorial.cpp | 67 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
index ef9b68feb..2e7d8bb66 100644
--- a/others/large_factorial.cpp
+++ b/others/large_factorial.cpp
@@ -92,6 +92,70 @@ private:
     vector<unsigned char> _digits; /**< where individual digits are stored */
 };
 
+bool test1()
+{
+    cout << "---- Check 1\t";
+    unsigned int i, number = 10;
+    large_number result;
+    for (i = 2; i <= number; i++)
+        /* Multiply every number from 2 thru N */
+        result.multiply(i);
+
+    const char *known_reslt = "3628800";
+
+    /* check 1 */
+    if (strlen(known_reslt) != result.num_digits())
+    {
+        cerr << "Result lengths dont match! " << strlen(known_reslt) << " != " << result.num_digits() << endl;
+        return false;
+    }
+
+    size_t N = result.num_digits();
+    for (i = 0; i < N; i++)
+    {
+        if (known_reslt[i] != (result[N - i - 1] + '0'))
+        {
+            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result[N - i - 1] << endl;
+            return false;
+        }
+    }
+
+    cout << "Passed!" << endl;
+    return true;
+}
+
+bool test2()
+{
+    cout << "---- Check 2\t";
+    unsigned int i, number = 100;
+    large_number result;
+    for (i = 2; i <= number; i++)
+        /* Multiply every number from 2 thru N */
+        result.multiply(i);
+
+    const char *known_reslt = "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000";
+
+    /* check 1 */
+    if (strlen(known_reslt) != result.num_digits())
+    {
+        cerr << "Result lengths dont match! " << strlen(known_reslt) << " != " << result.num_digits() << endl;
+        return false;
+    }
+
+    size_t N = result.num_digits();
+    for (i = 0; i < N; i++)
+    {
+        if (known_reslt[i] != (result[N - i - 1] + '0'))
+        {
+            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result[N - i - 1] << endl;
+            return false;
+        }
+    }
+
+    cout << "Passed!" << endl;
+    return true;
+}
+
 /**
  * Main program
  **/
@@ -124,5 +188,8 @@ int main(int argc, char *argv[])
          << "Time taken: " << time_taken.count() << " s"
          << endl;
 
+    test1();
+    test2();
+
     return 0;
 }

From a1997776c93904f0f4d66c1a802cd1429975bcf2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 15:57:12 -0400
Subject: [PATCH 003/290] split large_number class to a separate header file

---
 others/large_factorial.cpp | 114 ++-----------
 others/large_number.h      | 323 +++++++++++++++++++++++++++++++++++++
 2 files changed, 336 insertions(+), 101 deletions(-)
 create mode 100644 others/large_number.h

diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
index 2e7d8bb66..dccdcaeab 100644
--- a/others/large_factorial.cpp
+++ b/others/large_factorial.cpp
@@ -1,97 +1,10 @@
 #include <iostream>
+#include <string.h>
 #include <chrono>
-#include <vector>
+#include "large_number.h"
 
 using namespace std;
 
-/**
- * Store large unsigned numbers as a C++ vector
- * The class provides convenience functions to add a
- * digit to the number, perform multiplication of
- * large number with long unsigned integers.
- **/
-class large_number
-{
-public:
-    large_number() /**< initializer */
-    {
-        _digits.push_back(1);
-    }
-
-    /**
-     * add a digit to the large number
-     **/
-    void add_digit(unsigned int value)
-    {
-        if (value > 9)
-        {
-            fprintf(stderr, "digit > 9!!\n");
-            exit(EXIT_FAILURE);
-        }
-
-        _digits.push_back(value);
-    }
-
-    /**
-     * Get number of digits in the number
-     **/
-    const size_t num_digits() const
-    {
-        return _digits.size();
-    }
-
-    /**
-     * operator over load to access the
-     * i^th digit conveniently and also
-     * assign value to it
-     **/
-    unsigned char &operator[](size_t n)
-    {
-        return this->_digits[n];
-    }
-
-    /**
-     * multiply large number with another integer and
-     * store the result in the same large number
-     **/
-    void multiply(const unsigned long n)
-    {
-        size_t i;
-        unsigned long long carry = 0, temp;
-        for (i = 0; i < this->num_digits(); i++)
-        {
-            temp = (*this)[i] * n;
-            temp += carry;
-            if (temp < 10)
-                carry = 0;
-            else
-            {
-                carry = temp / 10;
-                temp = temp % 10;
-            }
-            (*this)[i] = temp;
-        }
-
-        while (carry != 0)
-        {
-            this->add_digit(carry % 10);
-            carry /= 10;
-        }
-    };
-
-    /**
-     * print the large number
-     **/
-    void print()
-    {
-        for (size_t i = num_digits(); i > 0; i--)
-            putchar(_digits[i - 1] + '0');
-    };
-
-private:
-    vector<unsigned char> _digits; /**< where individual digits are stored */
-};
-
 bool test1()
 {
     cout << "---- Check 1\t";
@@ -99,7 +12,7 @@ bool test1()
     large_number result;
     for (i = 2; i <= number; i++)
         /* Multiply every number from 2 thru N */
-        result.multiply(i);
+        result *= i;
 
     const char *known_reslt = "3628800";
 
@@ -110,12 +23,12 @@ bool test1()
         return false;
     }
 
-    size_t N = result.num_digits();
+    const size_t N = result.num_digits();
     for (i = 0; i < N; i++)
     {
-        if (known_reslt[i] != (result[N - i - 1] + '0'))
+        if (known_reslt[i] != result.digit_char(i))
         {
-            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result[N - i - 1] << endl;
+            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result.digit_char(i) << endl;
             return false;
         }
     }
@@ -131,7 +44,7 @@ bool test2()
     large_number result;
     for (i = 2; i <= number; i++)
         /* Multiply every number from 2 thru N */
-        result.multiply(i);
+        result *= i;
 
     const char *known_reslt = "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000";
 
@@ -142,12 +55,12 @@ bool test2()
         return false;
     }
 
-    size_t N = result.num_digits();
+    const size_t N = result.num_digits();
     for (i = 0; i < N; i++)
     {
-        if (known_reslt[i] != (result[N - i - 1] + '0'))
+        if (known_reslt[i] != result.digit_char(i))
         {
-            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result[N - i - 1] << endl;
+            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result.digit_char(i) << endl;
             return false;
         }
     }
@@ -177,19 +90,18 @@ int main(int argc, char *argv[])
     auto start_time = chrono::high_resolution_clock::now();
     for (i = 2; i <= number; i++)
         /* Multiply every number from 2 thru N */
-        result.multiply(i);
+        result *= i;
     auto end_time = chrono::high_resolution_clock::now();
     chrono::duration<double> time_taken = end_time - start_time;
 
-    cout << number << "! = ";
-    result.print();
-    cout << endl
+    cout << number << "! = " << result << endl
          << "Number of digits: " << result.num_digits() << endl
          << "Time taken: " << time_taken.count() << " s"
          << endl;
 
     test1();
     test2();
+    result.test();
 
     return 0;
 }
diff --git a/others/large_number.h b/others/large_number.h
new file mode 100644
index 000000000..0494a540b
--- /dev/null
+++ b/others/large_number.h
@@ -0,0 +1,323 @@
+/**
+ * @author Krishna Vedala
+ * @email krishna (dot) vedala (at) ieee (dot) org
+ **/
+
+#ifndef __LARGE_NUMBER__
+#define __LARGE_NUMBER__
+#include <type_traits>
+#include <iostream>
+#include <cassert>
+#include <vector>
+
+/**
+ * Store large unsigned numbers as a C++ vector
+ * The class provides convenience functions to add a
+ * digit to the number, perform multiplication of
+ * large number with long unsigned integers.
+ **/
+class large_number
+{
+public:
+    large_number() /**< initializer */
+    {
+        _digits.push_back(1);
+    }
+
+    large_number(unsigned long n) /**< initializer */
+    {
+        unsigned long carry = n;
+        do
+        {
+            add_digit(carry % 10);
+            carry /= 10;
+        } while (carry != 0);
+    }
+
+    large_number(const large_number &a) /**< initializer */
+    {
+        _digits = a._digits;
+    }
+
+    large_number(const std::vector<unsigned char> &vec) /**< initializer */
+    {
+        _digits = vec;
+    }
+
+    /**
+     * Function to check implementation
+     **/
+    static bool test()
+    {
+        std::cout << "------ Checking `large_number` class implementations\t" << std::endl;
+        large_number a(40);
+        a *= 10;
+        if (a != large_number(400))
+        {
+            std::cerr << "\tFailed 1/5 (" << a << "!=400)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 1/5...";
+        a += 120;
+        if (a != large_number(520))
+        {
+            std::cerr << "\tFailed 2/5 (" << a << "!=520)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 2/5...";
+        a *= 10;
+        if (a != large_number(5200))
+        {
+            std::cerr << "\tFailed 3/5 (" << a << "!=5200)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 3/5...";
+        ++a;
+        if (a != large_number(5201))
+        {
+            std::cerr << "\tFailed 4/5 (" << a << "!=5201)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 4/5...";
+        a++;
+        if (a != large_number(5202))
+        {
+            std::cerr << "\tFailed 5/5 (" << a << "!=5202)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 5/5..." << std::endl;
+        return true;
+    }
+
+    /**
+     * add a digit at MSB to the large number
+     **/
+    void add_digit(unsigned int value)
+    {
+        if (value > 9)
+        {
+            std::cerr << "digit > 9!!\n";
+            exit(EXIT_FAILURE);
+        }
+
+        _digits.push_back(value);
+    }
+
+    /**
+     * Get number of digits in the number
+     **/
+    const size_t num_digits() const
+    {
+        return _digits.size();
+    }
+
+    /**
+     * operator over load to access the
+     * i^th digit conveniently and also
+     * assign value to it
+     **/
+    inline unsigned char &operator[](size_t n)
+    {
+        return this->_digits[n];
+    }
+
+    inline const unsigned char &operator[](size_t n) const
+    {
+        return this->_digits[n];
+    }
+
+    /**
+     * operator overload to compare two numbers
+     **/
+    friend std::ostream &operator<<(std::ostream &out, const large_number &a)
+    {
+        for (size_t i = a.num_digits(); i > 0; i--)
+            out << a[i - 1] + '0';
+        return out;
+    }
+
+    /**
+     * operator overload to compare two numbers
+     **/
+    friend bool operator==(const large_number &a, const large_number b)
+    {
+        size_t N = a.num_digits();
+        if (N != b.num_digits())
+            return false;
+        for (size_t i = 0; i < N; i++)
+            if (a[i] != b[i])
+                return false;
+        return true;
+    }
+
+    /**
+     * operator overload to compare two numbers
+     **/
+    friend bool operator!=(const large_number &a, const large_number b)
+    {
+        return !(a == b);
+    }
+
+    /**
+     * operator overload to increment (prefix)
+     **/
+    large_number &operator++()
+    {
+        this->add((unsigned int)1);
+        return *this;
+    }
+
+    /**
+     * operator overload to increment (postfix)
+     **/
+    large_number &operator++(int)
+    {
+        large_number tmp(_digits);
+        ++(*this);
+        return tmp;
+    }
+
+    /**
+     * operator overload to add
+     **/
+    template <class T>
+    large_number &operator+=(T &n)
+    {
+        if (std::is_same<T, large_number>::value) // if adding with another large_number
+        {
+            large_number *b = &n;
+            const size_t max_L = std::max(this->num_digits(), b->num_digits());
+            unsigned int carry = 0, temp;
+            for (size_t i = 0; i < max_L; i++)
+            {
+                temp += carry;
+                if (i < b->num_digits())
+                    temp += (*b)[i];
+                if (i < this->num_digits())
+                    temp += (*this)[i];
+                if (temp < 10)
+                    carry = 0;
+                else
+                {
+                    carry = temp / 10;
+                    temp = temp % 10;
+                }
+                if (i < this->num_digits())
+                    (*this)[i] = temp;
+                else
+                    this->add_digit(temp);
+            }
+            while (carry != 0)
+            {
+                if (i < this->num_digits())
+                    (*this)[i] = carry % 10;
+                else
+                    this->add_digit(carry % 10);
+                carry /= 10;
+            }
+
+            return *this;
+        }
+
+        static_assert(std::is_integral<T>::value, "Must be integer addition unsigned integer types.");
+        // typedef typename std::make_unsigned<T>::type T2;
+        this->add(b);
+        return *this;
+    }
+
+    // /**
+    //  * operator overload to increment
+    //  **/
+    // friend large_number &operator+(large_number a, const large_number b)
+    // {
+    //     const size_t max_L = std::max(a.num_digits(), b.num_digits());
+
+    //     return a;
+    // }
+
+    /**
+     * operator overload to increment
+     **/
+    template <class T>
+    large_number &operator*=(const T n)
+    {
+        static_assert(std::is_integral<T>::value, "Must be integer addition unsigned integer types.");
+        this->multiply(n);
+        return *this;
+    }
+
+    /**
+     * returns i^th digit as an ASCII character
+     **/
+    const char digit_char(size_t i) const
+    {
+        return _digits[num_digits() - i - 1] + '0';
+    }
+
+private:
+    /**
+     * multiply large number with another integer and
+     * store the result in the same large number
+     **/
+    template <class T>
+    void multiply(const T n)
+    {
+        static_assert(std::is_integral<T>::value, "Can only have integer types.");
+        // assert(!(std::is_signed<T>::value)); //, "Implemented only for unsigned integer types.");
+
+        size_t i;
+        unsigned long long carry = 0, temp;
+        for (i = 0; i < this->num_digits(); i++)
+        {
+            temp = (*this)[i] * n;
+            temp += carry;
+            if (temp < 10)
+                carry = 0;
+            else
+            {
+                carry = temp / 10;
+                temp = temp % 10;
+            }
+            (*this)[i] = temp;
+        }
+
+        while (carry != 0)
+        {
+            this->add_digit(carry % 10);
+            carry /= 10;
+        }
+    };
+
+    /**
+     * add large number with another integer and
+     * store the result in the same large number
+     **/
+    template <class T>
+    void add(const T n)
+    {
+        static_assert(std::is_integral<T>::value, "Can only have integer types.");
+        // static_assert(!(std::is_signed<T>::value), "Implemented only for unsigned integer types.");
+
+        size_t i = 0;
+        long long carry = n;
+
+        while (carry != 0)
+        {
+            if (i < this->num_digits())
+            {
+                carry += (*this)[i];
+                (*this)[i] = carry % 10;
+                i++;
+            }
+            else
+                this->add_digit(carry % 10);
+            carry /= 10;
+            if (carry == 0)
+                return;
+        }
+    };
+
+    std::vector<unsigned char> _digits; /**< where individual digits are stored */
+};
+
+#endif

From 72ac15ed01dfd3064616a87053adfe7b2073f18e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 17:19:43 -0400
Subject: [PATCH 004/290] resolved compiler warnings

---
 others/large_number.h | 145 +++++++++++++++++-------------------------
 1 file changed, 60 insertions(+), 85 deletions(-)

diff --git a/others/large_number.h b/others/large_number.h
index 0494a540b..6d117d9dd 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -8,6 +8,7 @@
 #include <type_traits>
 #include <iostream>
 #include <cassert>
+#include <cstring>
 #include <vector>
 
 /**
@@ -19,12 +20,12 @@
 class large_number
 {
 public:
-    large_number() /**< initializer */
+    large_number() /**< initializer with value = 1 */
     {
         _digits.push_back(1);
     }
 
-    large_number(unsigned long n) /**< initializer */
+    large_number(unsigned long n) /**< initializer from an integer */
     {
         unsigned long carry = n;
         do
@@ -34,16 +35,22 @@ public:
         } while (carry != 0);
     }
 
-    large_number(const large_number &a) /**< initializer */
+    large_number(const large_number &a) /**< initializer from another large_number */
     {
         _digits = a._digits;
     }
 
-    large_number(const std::vector<unsigned char> &vec) /**< initializer */
+    large_number(const std::vector<unsigned char> &vec) /**< initializer from a vector */
     {
         _digits = vec;
     }
 
+    large_number(const char *number_str) /**< initializer from a string */
+    {
+        for (size_t i = strlen(number_str); i > 0; i--)
+            _digits.push_back(number_str[i - 1] - '0');
+    }
+
     /**
      * Function to check implementation
      **/
@@ -51,41 +58,54 @@ public:
     {
         std::cout << "------ Checking `large_number` class implementations\t" << std::endl;
         large_number a(40);
+        // 1. test multiplication
         a *= 10;
         if (a != large_number(400))
         {
-            std::cerr << "\tFailed 1/5 (" << a << "!=400)" << std::endl;
+            std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
             return false;
         }
-        std::cout << "\tPassed 1/5...";
+        std::cout << "\tPassed 1/6...";
+        // 2. test compound addition with integer
         a += 120;
         if (a != large_number(520))
         {
-            std::cerr << "\tFailed 2/5 (" << a << "!=520)" << std::endl;
+            std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
             return false;
         }
-        std::cout << "\tPassed 2/5...";
+        std::cout << "\tPassed 2/6...";
+        // 3. test compound multiplication again
         a *= 10;
         if (a != large_number(5200))
         {
-            std::cerr << "\tFailed 3/5 (" << a << "!=5200)" << std::endl;
+            std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
             return false;
         }
-        std::cout << "\tPassed 3/5...";
+        std::cout << "\tPassed 3/6...";
+        // 4. test increment (prefix)
         ++a;
         if (a != large_number(5201))
         {
-            std::cerr << "\tFailed 4/5 (" << a << "!=5201)" << std::endl;
+            std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
             return false;
         }
-        std::cout << "\tPassed 4/5...";
+        std::cout << "\tPassed 4/6...";
+        // 5. test increment (postfix)
         a++;
         if (a != large_number(5202))
         {
-            std::cerr << "\tFailed 5/5 (" << a << "!=5202)" << std::endl;
+            std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
             return false;
         }
-        std::cout << "\tPassed 5/5..." << std::endl;
+        std::cout << "\tPassed 5/6...";
+        // 6. test addition with another large number
+        a = a + large_number("7000000000000000000000000000000");
+        if (a != large_number("7000000000000000000000000005202"))
+        {
+            std::cerr << "\tFailed 6/6 (" << a << "!=7000000000000000000000000005202)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 6/6..." << std::endl;
         return true;
     }
 
@@ -132,14 +152,14 @@ public:
     friend std::ostream &operator<<(std::ostream &out, const large_number &a)
     {
         for (size_t i = a.num_digits(); i > 0; i--)
-            out << a[i - 1] + '0';
+            out << static_cast<int>(a[i - 1]);
         return out;
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator==(const large_number &a, const large_number b)
+    friend bool operator==(const large_number &a, const large_number &b)
     {
         size_t N = a.num_digits();
         if (N != b.num_digits())
@@ -153,7 +173,7 @@ public:
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator!=(const large_number &a, const large_number b)
+    friend bool operator!=(const large_number &a, const large_number &b)
     {
         return !(a == b);
     }
@@ -163,14 +183,14 @@ public:
      **/
     large_number &operator++()
     {
-        this->add((unsigned int)1);
+        (*this) += 1;
         return *this;
     }
 
     /**
      * operator overload to increment (postfix)
      **/
-    large_number &operator++(int)
+    large_number operator++(int)
     {
         large_number tmp(_digits);
         ++(*this);
@@ -181,59 +201,43 @@ public:
      * operator overload to add
      **/
     template <class T>
-    large_number &operator+=(T &n)
+    large_number &operator+=(T n)
     {
-        if (std::is_same<T, large_number>::value) // if adding with another large_number
+        if (typeid(T) == typeid(large_number)) // if adding with another large_number
         {
-            large_number *b = &n;
+            large_number *b = (large_number *)&n;
             const size_t max_L = std::max(this->num_digits(), b->num_digits());
-            unsigned int carry = 0, temp;
-            for (size_t i = 0; i < max_L; i++)
+            unsigned int carry = 0;
+            size_t i;
+            for (i = 0; i < max_L || carry != 0; i++)
             {
-                temp += carry;
                 if (i < b->num_digits())
-                    temp += (*b)[i];
+                    carry += (*b)[i];
                 if (i < this->num_digits())
-                    temp += (*this)[i];
-                if (temp < 10)
-                    carry = 0;
-                else
-                {
-                    carry = temp / 10;
-                    temp = temp % 10;
-                }
-                if (i < this->num_digits())
-                    (*this)[i] = temp;
-                else
-                    this->add_digit(temp);
-            }
-            while (carry != 0)
-            {
+                    carry += (*this)[i];
                 if (i < this->num_digits())
                     (*this)[i] = carry % 10;
                 else
                     this->add_digit(carry % 10);
                 carry /= 10;
             }
-
-            return *this;
         }
-
-        static_assert(std::is_integral<T>::value, "Must be integer addition unsigned integer types.");
-        // typedef typename std::make_unsigned<T>::type T2;
-        this->add(b);
+        else if (std::is_integral<T>::value)
+            return (*this) += large_number(n);
+        else
+            std::cerr << "Must be integer addition unsigned integer types." << std::endl;
         return *this;
     }
 
-    // /**
-    //  * operator overload to increment
-    //  **/
-    // friend large_number &operator+(large_number a, const large_number b)
-    // {
-    //     const size_t max_L = std::max(a.num_digits(), b.num_digits());
-
-    //     return a;
-    // }
+    /**
+     * operator overload to perform addition
+     **/
+    template <class T>
+    friend large_number &operator+(large_number &a, const T &b)
+    {
+        a += b;
+        return a;
+    }
 
     /**
      * operator overload to increment
@@ -288,35 +292,6 @@ private:
         }
     };
 
-    /**
-     * add large number with another integer and
-     * store the result in the same large number
-     **/
-    template <class T>
-    void add(const T n)
-    {
-        static_assert(std::is_integral<T>::value, "Can only have integer types.");
-        // static_assert(!(std::is_signed<T>::value), "Implemented only for unsigned integer types.");
-
-        size_t i = 0;
-        long long carry = n;
-
-        while (carry != 0)
-        {
-            if (i < this->num_digits())
-            {
-                carry += (*this)[i];
-                (*this)[i] = carry % 10;
-                i++;
-            }
-            else
-                this->add_digit(carry % 10);
-            carry /= 10;
-            if (carry == 0)
-                return;
-        }
-    };
-
     std::vector<unsigned char> _digits; /**< where individual digits are stored */
 };
 

From 1cb1641abc35fed7143c6d4ec7af8739bc056810 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 17:56:19 -0400
Subject: [PATCH 005/290] compute arbitrarily large fibonacci number

---
 others/fibonacci_large.cpp | 51 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 others/fibonacci_large.cpp

diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
new file mode 100644
index 000000000..709268b66
--- /dev/null
+++ b/others/fibonacci_large.cpp
@@ -0,0 +1,51 @@
+/**
+ * Computes N^th Fibonacci number given as
+ * input argument. Uses custom build arbitrary integers library
+ * to perform additions and other operations.
+ *
+ * Took 0.608246 seconds to compute 50,000^th Fibonacci
+ * number that contains 10450 digits!
+ **/
+
+#include "large_number.h"
+#include <iostream>
+#include <chrono>
+
+large_number fib(unsigned long long n)
+{
+    large_number f0(1);
+    large_number f1(1);
+
+    do
+    {
+        large_number f2 = f0 + f1;
+        f0 = f1;
+        f1 = f2;
+        n--;
+    } while (n > 2); // since we start from 2
+    return f1;
+}
+
+int main(int argc, char *argv[])
+{
+    unsigned long long N;
+    if (argc == 2)
+        N = strtoull(argv[1], NULL, 10);
+    else
+    {
+        std::cout << "Enter N: ";
+        std::cin >> N;
+    }
+
+    auto start_time = std::chrono::high_resolution_clock::now();
+    large_number result = fib(N);
+    auto end_time = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> time_taken = end_time - start_time;
+
+    std::cout
+        << std::endl
+        << N << "^th Fibonacci number: " << result << std::endl
+        << "Number of digits: " << result.num_digits() << std::endl
+        << "Time taken: " << time_taken.count() << " s" << std::endl;
+    return 0;
+}
\ No newline at end of file

From f4778612e071ee5c1502ab736ed822b8b81b2678 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 17:56:42 -0400
Subject: [PATCH 006/290] large_number: created assignment operator

---
 others/large_number.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/others/large_number.h b/others/large_number.h
index 6d117d9dd..8a6afcaa4 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -239,6 +239,14 @@ public:
         return a;
     }
 
+    /**
+     * assignment operator
+     **/
+    void operator=(const large_number &b)
+    {
+        _digits = b._digits;
+    }
+
     /**
      * operator overload to increment
      **/

From 9b538f3783415e7172a5372800ea965dc911b7ba Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 18:04:58 -0400
Subject: [PATCH 007/290] ignore non numeric characters when creating
 large_number from a string

---
 others/large_number.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/others/large_number.h b/others/large_number.h
index 8a6afcaa4..8c7f688d0 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -48,7 +48,11 @@ public:
     large_number(const char *number_str) /**< initializer from a string */
     {
         for (size_t i = strlen(number_str); i > 0; i--)
-            _digits.push_back(number_str[i - 1] - '0');
+        {
+            unsigned char a = number_str[i - 1] - '0';
+            if (a >= 0 && a <= 9)
+                _digits.push_back(a);
+        }
     }
 
     /**

From 9c633857bd396bbf490ad8e736832f31ca4caced Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 18:05:11 -0400
Subject: [PATCH 008/290] added test case

---
 others/fibonacci_large.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index 709268b66..a47e967d3 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -47,5 +47,11 @@ int main(int argc, char *argv[])
         << N << "^th Fibonacci number: " << result << std::endl
         << "Number of digits: " << result.num_digits() << std::endl
         << "Time taken: " << time_taken.count() << " s" << std::endl;
+
+    if (fib(5000) == large_number("3878968454388325633701916308325905312082127714646245106160597214895550139044037097010822916462210669479293452858882973813483102008954982940361430156911478938364216563944106910214505634133706558656238254656700712525929903854933813928836378347518908762970712033337052923107693008518093849801803847813996748881765554653788291644268912980384613778969021502293082475666346224923071883324803280375039130352903304505842701147635242270210934637699104006714174883298422891491273104054328753298044273676822977244987749874555691907703880637046832794811358973739993110106219308149018570815397854379195305617510761053075688783766033667355445258844886241619210553457493675897849027988234351023599844663934853256411952221859563060475364645470760330902420806382584929156452876291575759142343809142302917491088984155209854432486594079793571316841692868039545309545388698114665082066862897420639323438488465240988742395873801976993820317174208932265468879364002630797780058759129671389634214252579116872755600360311370547754724604639987588046985178408674382863125"))
+        std::cout << "Test for 5000^th Fibonacci number passed!" << std::endl;
+    else
+        std::cerr << "Test for 5000^th Fibonacci number failed!" << std::endl;
+
     return 0;
 }
\ No newline at end of file

From 90840a1e3747ce65fb4c557ce6f13ee51f30d416 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 18:06:41 -0400
Subject: [PATCH 009/290] user editable test "N"

---
 others/fibonacci_large.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index a47e967d3..12b926759 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -48,10 +48,11 @@ int main(int argc, char *argv[])
         << "Number of digits: " << result.num_digits() << std::endl
         << "Time taken: " << time_taken.count() << " s" << std::endl;
 
-    if (fib(5000) == large_number("3878968454388325633701916308325905312082127714646245106160597214895550139044037097010822916462210669479293452858882973813483102008954982940361430156911478938364216563944106910214505634133706558656238254656700712525929903854933813928836378347518908762970712033337052923107693008518093849801803847813996748881765554653788291644268912980384613778969021502293082475666346224923071883324803280375039130352903304505842701147635242270210934637699104006714174883298422891491273104054328753298044273676822977244987749874555691907703880637046832794811358973739993110106219308149018570815397854379195305617510761053075688783766033667355445258844886241619210553457493675897849027988234351023599844663934853256411952221859563060475364645470760330902420806382584929156452876291575759142343809142302917491088984155209854432486594079793571316841692868039545309545388698114665082066862897420639323438488465240988742395873801976993820317174208932265468879364002630797780058759129671389634214252579116872755600360311370547754724604639987588046985178408674382863125"))
-        std::cout << "Test for 5000^th Fibonacci number passed!" << std::endl;
+    N = 5000;
+    if (fib(N) == large_number("3878968454388325633701916308325905312082127714646245106160597214895550139044037097010822916462210669479293452858882973813483102008954982940361430156911478938364216563944106910214505634133706558656238254656700712525929903854933813928836378347518908762970712033337052923107693008518093849801803847813996748881765554653788291644268912980384613778969021502293082475666346224923071883324803280375039130352903304505842701147635242270210934637699104006714174883298422891491273104054328753298044273676822977244987749874555691907703880637046832794811358973739993110106219308149018570815397854379195305617510761053075688783766033667355445258844886241619210553457493675897849027988234351023599844663934853256411952221859563060475364645470760330902420806382584929156452876291575759142343809142302917491088984155209854432486594079793571316841692868039545309545388698114665082066862897420639323438488465240988742395873801976993820317174208932265468879364002630797780058759129671389634214252579116872755600360311370547754724604639987588046985178408674382863125"))
+        std::cout << "Test for " << N << "^th Fibonacci number passed!" << std::endl;
     else
-        std::cerr << "Test for 5000^th Fibonacci number failed!" << std::endl;
+        std::cerr << "Test for " << N << "^th Fibonacci number failed!" << std::endl;
 
     return 0;
 }
\ No newline at end of file

From f1b07d33a7e47921862b9702a35f6d2d1007c099 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Sat, 2 May 2020 18:10:15 -0400
Subject: [PATCH 010/290] remove incorrect comment

---
 others/large_factorial.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
index dccdcaeab..5ee116b4c 100644
--- a/others/large_factorial.cpp
+++ b/others/large_factorial.cpp
@@ -76,7 +76,6 @@ int main(int argc, char *argv[])
 {
     int number, i;
 
-    //Asks for the number/position of term in Fibonnacci sequence
     if (argc == 2)
         number = atoi(argv[1]);
     else

From a77151c254d6c820b4af9984814b8cb6d77b1df1 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Sun, 24 May 2020 18:38:16 +0000
Subject: [PATCH 011/290] updating DIRECTORY.md

---
 DIRECTORY.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index ddbfd06d8..d7c138621 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -137,8 +137,11 @@
   * [Decimal To Roman Numeral](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Decimal%20to%20Roman%20Numeral.cpp)
   * [Fast Interger Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_interger_input.cpp)
   * [Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci.cpp)
+  * [Fibonacci Large](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_large.cpp)
   * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/GCD_of_n_numbers.cpp)
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
+  * [Large Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/large_factorial.cpp)
+  * [Large Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/large_number.h)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
   * [Measure Time Elapsed](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/measure_time_elapsed.cpp)
   * [Palindromeofnumber](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Palindromeofnumber.cpp)

From 236b6581302989cc5770233ec0ed6c58db621642 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sun, 24 May 2020 15:56:45 -0400
Subject: [PATCH 012/290] replace `std::chronos` with `ctime` - cpplint does
 not allow c++-11

---
 others/fibonacci_large.cpp |  61 +++++++++------
 others/large_factorial.cpp |  91 +++++++++++-----------
 others/large_number.h      | 152 +++++++++++++++----------------------
 3 files changed, 142 insertions(+), 162 deletions(-)

diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index 12b926759..bdfb201a5 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -7,52 +7,69 @@
  * number that contains 10450 digits!
  **/
 
-#include "large_number.h"
+#include <ctime>
 #include <iostream>
-#include <chrono>
 
-large_number fib(unsigned long long n)
-{
+#include "large_number.h"
+
+large_number fib(unsigned long long n) {
     large_number f0(1);
     large_number f1(1);
 
-    do
-    {
+    do {
         large_number f2 = f0 + f1;
         f0 = f1;
         f1 = f2;
         n--;
-    } while (n > 2); // since we start from 2
+    } while (n > 2);  // since we start from 2
     return f1;
 }
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     unsigned long long N;
     if (argc == 2)
         N = strtoull(argv[1], NULL, 10);
-    else
-    {
+    else {
         std::cout << "Enter N: ";
         std::cin >> N;
     }
 
-    auto start_time = std::chrono::high_resolution_clock::now();
+    clock_t start_time = std::clock();
     large_number result = fib(N);
-    auto end_time = std::chrono::high_resolution_clock::now();
-    std::chrono::duration<double> time_taken = end_time - start_time;
+    clock_t end_time = std::clock();
+    double time_taken = static_cast<double>(end_time - start_time) /
+                        static_cast<double>(CLOCKS_PER_SEC);
 
-    std::cout
-        << std::endl
-        << N << "^th Fibonacci number: " << result << std::endl
-        << "Number of digits: " << result.num_digits() << std::endl
-        << "Time taken: " << time_taken.count() << " s" << std::endl;
+    std::cout << std::endl
+              << N << "^th Fibonacci number: " << result << std::endl
+              << "Number of digits: " << result.num_digits() << std::endl
+              << "Time taken: " << std::scientific << time_taken << " s"
+              << std::endl;
 
     N = 5000;
-    if (fib(N) == large_number("3878968454388325633701916308325905312082127714646245106160597214895550139044037097010822916462210669479293452858882973813483102008954982940361430156911478938364216563944106910214505634133706558656238254656700712525929903854933813928836378347518908762970712033337052923107693008518093849801803847813996748881765554653788291644268912980384613778969021502293082475666346224923071883324803280375039130352903304505842701147635242270210934637699104006714174883298422891491273104054328753298044273676822977244987749874555691907703880637046832794811358973739993110106219308149018570815397854379195305617510761053075688783766033667355445258844886241619210553457493675897849027988234351023599844663934853256411952221859563060475364645470760330902420806382584929156452876291575759142343809142302917491088984155209854432486594079793571316841692868039545309545388698114665082066862897420639323438488465240988742395873801976993820317174208932265468879364002630797780058759129671389634214252579116872755600360311370547754724604639987588046985178408674382863125"))
-        std::cout << "Test for " << N << "^th Fibonacci number passed!" << std::endl;
+    if (fib(N) ==
+        large_number(
+            "387896845438832563370191630832590531208212771464624510616059721489"
+            "555013904403709701082291646221066947929345285888297381348310200895"
+            "498294036143015691147893836421656394410691021450563413370655865623"
+            "825465670071252592990385493381392883637834751890876297071203333705"
+            "292310769300851809384980180384781399674888176555465378829164426891"
+            "298038461377896902150229308247566634622492307188332480328037503913"
+            "035290330450584270114763524227021093463769910400671417488329842289"
+            "149127310405432875329804427367682297724498774987455569190770388063"
+            "704683279481135897373999311010621930814901857081539785437919530561"
+            "751076105307568878376603366735544525884488624161921055345749367589"
+            "784902798823435102359984466393485325641195222185956306047536464547"
+            "076033090242080638258492915645287629157575914234380914230291749108"
+            "898415520985443248659407979357131684169286803954530954538869811466"
+            "508206686289742063932343848846524098874239587380197699382031717420"
+            "893226546887936400263079778005875912967138963421425257911687275560"
+            "0360311370547754724604639987588046985178408674382863125"))
+        std::cout << "Test for " << N << "^th Fibonacci number passed!"
+                  << std::endl;
     else
-        std::cerr << "Test for " << N << "^th Fibonacci number failed!" << std::endl;
+        std::cerr << "Test for " << N << "^th Fibonacci number failed!"
+                  << std::endl;
 
     return 0;
 }
\ No newline at end of file
diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
index 5ee116b4c..f06f4e7af 100644
--- a/others/large_factorial.cpp
+++ b/others/large_factorial.cpp
@@ -1,102 +1,97 @@
-#include <iostream>
 #include <string.h>
-#include <chrono>
+
+#include <ctime>
+#include <iostream>
+
 #include "large_number.h"
 
-using namespace std;
-
-bool test1()
-{
-    cout << "---- Check 1\t";
+bool test1() {
+    std::cout << "---- Check 1\t";
     unsigned int i, number = 10;
     large_number result;
-    for (i = 2; i <= number; i++)
-        /* Multiply every number from 2 thru N */
+    for (i = 2; i <= number; i++) /* Multiply every number from 2 thru N */
         result *= i;
 
     const char *known_reslt = "3628800";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits())
-    {
-        cerr << "Result lengths dont match! " << strlen(known_reslt) << " != " << result.num_digits() << endl;
+    if (strlen(known_reslt) != result.num_digits()) {
+        std::cerr << "Result lengths dont match! " << strlen(known_reslt)
+                  << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++)
-    {
-        if (known_reslt[i] != result.digit_char(i))
-        {
-            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result.digit_char(i) << endl;
+    for (i = 0; i < N; i++) {
+        if (known_reslt[i] != result.digit_char(i)) {
+            std::cerr << i << "^th digit mismatch! " << known_reslt[i]
+                      << " != " << result.digit_char(i) << std::endl;
             return false;
         }
     }
 
-    cout << "Passed!" << endl;
+    std::cout << "Passed!" << std::endl;
     return true;
 }
 
-bool test2()
-{
-    cout << "---- Check 2\t";
+bool test2() {
+    std::cout << "---- Check 2\t";
     unsigned int i, number = 100;
     large_number result;
-    for (i = 2; i <= number; i++)
-        /* Multiply every number from 2 thru N */
+    for (i = 2; i <= number; i++) /* Multiply every number from 2 thru N */
         result *= i;
 
-    const char *known_reslt = "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000";
+    const char *known_reslt =
+        "9332621544394415268169923885626670049071596826438162146859296389521759"
+        "9993229915608941463976156518286253697920827223758251185210916864000000"
+        "000000000000000000";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits())
-    {
-        cerr << "Result lengths dont match! " << strlen(known_reslt) << " != " << result.num_digits() << endl;
+    if (strlen(known_reslt) != result.num_digits()) {
+        std::cerr << "Result lengths dont match! " << strlen(known_reslt)
+                  << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++)
-    {
-        if (known_reslt[i] != result.digit_char(i))
-        {
-            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result.digit_char(i) << endl;
+    for (i = 0; i < N; i++) {
+        if (known_reslt[i] != result.digit_char(i)) {
+            std::cerr << i << "^th digit mismatch! " << known_reslt[i]
+                      << " != " << result.digit_char(i) << std::endl;
             return false;
         }
     }
 
-    cout << "Passed!" << endl;
+    std::cout << "Passed!" << std::endl;
     return true;
 }
 
 /**
  * Main program
  **/
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     int number, i;
 
     if (argc == 2)
         number = atoi(argv[1]);
-    else
-    {
-        printf("Enter the value of n(n starts from 0 ): ");
-        scanf("%d", &number);
+    else {
+        std::cout << "Enter the value of n(n starts from 0 ): ";
+        std::cin >> number;
     }
 
     large_number result;
 
-    auto start_time = chrono::high_resolution_clock::now();
-    for (i = 2; i <= number; i++)
-        /* Multiply every number from 2 thru N */
+    std::clock_t start_time = std::clock();
+    for (i = 2; i <= number; i++) /* Multiply every number from 2 thru N */
         result *= i;
-    auto end_time = chrono::high_resolution_clock::now();
-    chrono::duration<double> time_taken = end_time - start_time;
+    std::clock_t end_time = std::clock();
+    double time_taken =
+        static_cast<double>(end_time - start_time) / CLOCKS_PER_SEC;
 
-    cout << number << "! = " << result << endl
-         << "Number of digits: " << result.num_digits() << endl
-         << "Time taken: " << time_taken.count() << " s"
-         << endl;
+    std::cout << number << "! = " << result << std::endl
+              << "Number of digits: " << result.num_digits() << std::endl
+              << "Time taken: " << std::scientific << time_taken << " s"
+              << std::endl;
 
     test1();
     test2();
diff --git a/others/large_number.h b/others/large_number.h
index 8c7f688d0..4657e87af 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -5,10 +5,10 @@
 
 #ifndef __LARGE_NUMBER__
 #define __LARGE_NUMBER__
-#include <type_traits>
-#include <iostream>
 #include <cassert>
 #include <cstring>
+#include <iostream>
+#include <type_traits>
 #include <vector>
 
 /**
@@ -17,9 +17,8 @@
  * digit to the number, perform multiplication of
  * large number with long unsigned integers.
  **/
-class large_number
-{
-public:
+class large_number {
+   public:
     large_number() /**< initializer with value = 1 */
     {
         _digits.push_back(1);
@@ -28,85 +27,79 @@ public:
     large_number(unsigned long n) /**< initializer from an integer */
     {
         unsigned long carry = n;
-        do
-        {
+        do {
             add_digit(carry % 10);
             carry /= 10;
         } while (carry != 0);
     }
 
-    large_number(const large_number &a) /**< initializer from another large_number */
+    large_number(
+        const large_number &a) /**< initializer from another large_number */
     {
         _digits = a._digits;
     }
 
-    large_number(const std::vector<unsigned char> &vec) /**< initializer from a vector */
+    large_number(
+        const std::vector<unsigned char> &vec) /**< initializer from a vector */
     {
         _digits = vec;
     }
 
     large_number(const char *number_str) /**< initializer from a string */
     {
-        for (size_t i = strlen(number_str); i > 0; i--)
-        {
+        for (size_t i = strlen(number_str); i > 0; i--) {
             unsigned char a = number_str[i - 1] - '0';
-            if (a >= 0 && a <= 9)
-                _digits.push_back(a);
+            if (a >= 0 && a <= 9) _digits.push_back(a);
         }
     }
 
     /**
      * Function to check implementation
      **/
-    static bool test()
-    {
-        std::cout << "------ Checking `large_number` class implementations\t" << std::endl;
+    static bool test() {
+        std::cout << "------ Checking `large_number` class implementations\t"
+                  << std::endl;
         large_number a(40);
         // 1. test multiplication
         a *= 10;
-        if (a != large_number(400))
-        {
+        if (a != large_number(400)) {
             std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 1/6...";
         // 2. test compound addition with integer
         a += 120;
-        if (a != large_number(520))
-        {
+        if (a != large_number(520)) {
             std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 2/6...";
         // 3. test compound multiplication again
         a *= 10;
-        if (a != large_number(5200))
-        {
+        if (a != large_number(5200)) {
             std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 3/6...";
         // 4. test increment (prefix)
         ++a;
-        if (a != large_number(5201))
-        {
+        if (a != large_number(5201)) {
             std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 4/6...";
         // 5. test increment (postfix)
         a++;
-        if (a != large_number(5202))
-        {
+        if (a != large_number(5202)) {
             std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 5/6...";
         // 6. test addition with another large number
         a = a + large_number("7000000000000000000000000000000");
-        if (a != large_number("7000000000000000000000000005202"))
-        {
-            std::cerr << "\tFailed 6/6 (" << a << "!=7000000000000000000000000005202)" << std::endl;
+        if (a != large_number("7000000000000000000000000005202")) {
+            std::cerr << "\tFailed 6/6 (" << a
+                      << "!=7000000000000000000000000005202)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 6/6..." << std::endl;
@@ -116,10 +109,8 @@ public:
     /**
      * add a digit at MSB to the large number
      **/
-    void add_digit(unsigned int value)
-    {
-        if (value > 9)
-        {
+    void add_digit(unsigned int value) {
+        if (value > 9) {
             std::cerr << "digit > 9!!\n";
             exit(EXIT_FAILURE);
         }
@@ -130,31 +121,23 @@ public:
     /**
      * Get number of digits in the number
      **/
-    const size_t num_digits() const
-    {
-        return _digits.size();
-    }
+    const size_t num_digits() const { return _digits.size(); }
 
     /**
      * operator over load to access the
      * i^th digit conveniently and also
      * assign value to it
      **/
-    inline unsigned char &operator[](size_t n)
-    {
-        return this->_digits[n];
-    }
+    inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
 
-    inline const unsigned char &operator[](size_t n) const
-    {
+    inline const unsigned char &operator[](size_t n) const {
         return this->_digits[n];
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend std::ostream &operator<<(std::ostream &out, const large_number &a)
-    {
+    friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
         for (size_t i = a.num_digits(); i > 0; i--)
             out << static_cast<int>(a[i - 1]);
         return out;
@@ -163,30 +146,25 @@ public:
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator==(const large_number &a, const large_number &b)
-    {
+    friend bool operator==(large_number const &a, large_number const &b) {
         size_t N = a.num_digits();
-        if (N != b.num_digits())
-            return false;
+        if (N != b.num_digits()) return false;
         for (size_t i = 0; i < N; i++)
-            if (a[i] != b[i])
-                return false;
+            if (a[i] != b[i]) return false;
         return true;
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator!=(const large_number &a, const large_number &b)
-    {
+    friend bool operator!=(large_number const &a, large_number const &b) {
         return !(a == b);
     }
 
     /**
      * operator overload to increment (prefix)
      **/
-    large_number &operator++()
-    {
+    large_number &operator++() {
         (*this) += 1;
         return *this;
     }
@@ -194,8 +172,7 @@ public:
     /**
      * operator overload to increment (postfix)
      **/
-    large_number operator++(int)
-    {
+    large_number operator++(int) {
         large_number tmp(_digits);
         ++(*this);
         return tmp;
@@ -205,31 +182,28 @@ public:
      * operator overload to add
      **/
     template <class T>
-    large_number &operator+=(T n)
-    {
-        if (typeid(T) == typeid(large_number)) // if adding with another large_number
+    large_number &operator+=(T n) {
+        if (typeid(T) ==
+            typeid(large_number))  // if adding with another large_number
         {
             large_number *b = (large_number *)&n;
             const size_t max_L = std::max(this->num_digits(), b->num_digits());
             unsigned int carry = 0;
             size_t i;
-            for (i = 0; i < max_L || carry != 0; i++)
-            {
-                if (i < b->num_digits())
-                    carry += (*b)[i];
-                if (i < this->num_digits())
-                    carry += (*this)[i];
+            for (i = 0; i < max_L || carry != 0; i++) {
+                if (i < b->num_digits()) carry += (*b)[i];
+                if (i < this->num_digits()) carry += (*this)[i];
                 if (i < this->num_digits())
                     (*this)[i] = carry % 10;
                 else
                     this->add_digit(carry % 10);
                 carry /= 10;
             }
-        }
-        else if (std::is_integral<T>::value)
+        } else if (std::is_integral<T>::value)
             return (*this) += large_number(n);
         else
-            std::cerr << "Must be integer addition unsigned integer types." << std::endl;
+            std::cerr << "Must be integer addition unsigned integer types."
+                      << std::endl;
         return *this;
     }
 
@@ -237,8 +211,7 @@ public:
      * operator overload to perform addition
      **/
     template <class T>
-    friend large_number &operator+(large_number &a, const T &b)
-    {
+    friend large_number &operator+(large_number &a, const T &b) {
         a += b;
         return a;
     }
@@ -246,18 +219,15 @@ public:
     /**
      * assignment operator
      **/
-    void operator=(const large_number &b)
-    {
-        _digits = b._digits;
-    }
+    void operator=(const large_number &b) { _digits = b._digits; }
 
     /**
      * operator overload to increment
      **/
     template <class T>
-    large_number &operator*=(const T n)
-    {
-        static_assert(std::is_integral<T>::value, "Must be integer addition unsigned integer types.");
+    large_number &operator*=(const T n) {
+        static_assert(std::is_integral<T>::value,
+                      "Must be integer addition unsigned integer types.");
         this->multiply(n);
         return *this;
     }
@@ -265,46 +235,44 @@ public:
     /**
      * returns i^th digit as an ASCII character
      **/
-    const char digit_char(size_t i) const
-    {
+    const char digit_char(size_t i) const {
         return _digits[num_digits() - i - 1] + '0';
     }
 
-private:
+   private:
     /**
      * multiply large number with another integer and
      * store the result in the same large number
      **/
     template <class T>
-    void multiply(const T n)
-    {
-        static_assert(std::is_integral<T>::value, "Can only have integer types.");
-        // assert(!(std::is_signed<T>::value)); //, "Implemented only for unsigned integer types.");
+    void multiply(const T n) {
+        static_assert(std::is_integral<T>::value,
+                      "Can only have integer types.");
+        // assert(!(std::is_signed<T>::value)); //, "Implemented only for
+        // unsigned integer types.");
 
         size_t i;
         unsigned long long carry = 0, temp;
-        for (i = 0; i < this->num_digits(); i++)
-        {
+        for (i = 0; i < this->num_digits(); i++) {
             temp = (*this)[i] * n;
             temp += carry;
             if (temp < 10)
                 carry = 0;
-            else
-            {
+            else {
                 carry = temp / 10;
                 temp = temp % 10;
             }
             (*this)[i] = temp;
         }
 
-        while (carry != 0)
-        {
+        while (carry != 0) {
             this->add_digit(carry % 10);
             carry /= 10;
         }
     };
 
-    std::vector<unsigned char> _digits; /**< where individual digits are stored */
+    std::vector<unsigned char>
+        _digits; /**< where individual digits are stored */
 };
 
 #endif

From e989ad0fe5bf7b59dadbb11bbc44aba7e6654756 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sun, 24 May 2020 16:02:00 -0400
Subject: [PATCH 013/290] cpp lint fixes

---
 others/fibonacci_large.cpp | 13 +++++++------
 others/large_factorial.cpp |  6 +++---
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index bdfb201a5..0333feb81 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -7,12 +7,13 @@
  * number that contains 10450 digits!
  **/
 
+#include <cinttypes>
 #include <ctime>
 #include <iostream>
 
-#include "large_number.h"
+#include "./large_number.h"
 
-large_number fib(unsigned long long n) {
+large_number fib(uint64_t n) {
     large_number f0(1);
     large_number f1(1);
 
@@ -26,10 +27,10 @@ large_number fib(unsigned long long n) {
 }
 
 int main(int argc, char *argv[]) {
-    unsigned long long N;
-    if (argc == 2)
+    uint64_t N;
+    if (argc == 2) {
         N = strtoull(argv[1], NULL, 10);
-    else {
+    } else {
         std::cout << "Enter N: ";
         std::cin >> N;
     }
@@ -72,4 +73,4 @@ int main(int argc, char *argv[]) {
                   << std::endl;
 
     return 0;
-}
\ No newline at end of file
+}
diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
index f06f4e7af..6d5385589 100644
--- a/others/large_factorial.cpp
+++ b/others/large_factorial.cpp
@@ -3,7 +3,7 @@
 #include <ctime>
 #include <iostream>
 
-#include "large_number.h"
+#include "./large_number.h"
 
 bool test1() {
     std::cout << "---- Check 1\t";
@@ -72,9 +72,9 @@ bool test2() {
 int main(int argc, char *argv[]) {
     int number, i;
 
-    if (argc == 2)
+    if (argc == 2) {
         number = atoi(argv[1]);
-    else {
+    } else {
         std::cout << "Enter the value of n(n starts from 0 ): ";
         std::cin >> number;
     }

From 045a1dc977f309a52d121b1efe66fb6a25e3fb29 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sun, 24 May 2020 16:08:00 -0400
Subject: [PATCH 014/290] more cpp lint fixes

---
 others/large_number.h | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/others/large_number.h b/others/large_number.h
index 4657e87af..abc63b765 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -3,8 +3,8 @@
  * @email krishna (dot) vedala (at) ieee (dot) org
  **/
 
-#ifndef __LARGE_NUMBER__
-#define __LARGE_NUMBER__
+#ifndef OTHERS_LARGE_NUMBER_H_
+#define OTHERS_LARGE_NUMBER_H_
 #include <cassert>
 #include <cstring>
 #include <iostream>
@@ -18,11 +18,8 @@
  * large number with long unsigned integers.
  **/
 class large_number {
-   public:
-    large_number() /**< initializer with value = 1 */
-    {
-        _digits.push_back(1);
-    }
+public:
+    large_number() /**< initializer with value = 1 */ { _digits.push_back(1); }
 
     large_number(unsigned long n) /**< initializer from an integer */
     {
@@ -49,7 +46,8 @@ class large_number {
     {
         for (size_t i = strlen(number_str); i > 0; i--) {
             unsigned char a = number_str[i - 1] - '0';
-            if (a >= 0 && a <= 9) _digits.push_back(a);
+            if (a >= 0 && a <= 9)
+                _digits.push_back(a);
         }
     }
 
@@ -148,9 +146,11 @@ class large_number {
      **/
     friend bool operator==(large_number const &a, large_number const &b) {
         size_t N = a.num_digits();
-        if (N != b.num_digits()) return false;
+        if (N != b.num_digits())
+            return false;
         for (size_t i = 0; i < N; i++)
-            if (a[i] != b[i]) return false;
+            if (a[i] != b[i])
+                return false;
         return true;
     }
 
@@ -191,8 +191,10 @@ class large_number {
             unsigned int carry = 0;
             size_t i;
             for (i = 0; i < max_L || carry != 0; i++) {
-                if (i < b->num_digits()) carry += (*b)[i];
-                if (i < this->num_digits()) carry += (*this)[i];
+                if (i < b->num_digits())
+                    carry += (*b)[i];
+                if (i < this->num_digits())
+                    carry += (*this)[i];
                 if (i < this->num_digits())
                     (*this)[i] = carry % 10;
                 else
@@ -239,7 +241,7 @@ class large_number {
         return _digits[num_digits() - i - 1] + '0';
     }
 
-   private:
+private:
     /**
      * multiply large number with another integer and
      * store the result in the same large number
@@ -275,4 +277,4 @@ class large_number {
         _digits; /**< where individual digits are stored */
 };
 
-#endif
+#endif  // OTHERS_LARGE_NUMBER_H_

From ca08e3e9a21a16ad08d97f3ceb06d4a511bc1c39 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sun, 24 May 2020 16:08:12 -0400
Subject: [PATCH 015/290] updated vscode settings

---
 .vscode/settings.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 0ab2708d0..5815b2666 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -64,7 +64,7 @@
           "valarray": "cpp",
           "algorithm": "cpp"
      },
-     "C_Cpp.clang_format_style": "{BasedOnStyle: Google, IndentWidth: 4, ColumnLimit: 80, UseTab: Never}",
+     "C_Cpp.clang_format_style": "{ BasedOnStyle: Google, UseTab: Never, IndentWidth: 4, TabWidth: 4,, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 80, AccessModifierOffset: -4, NamespaceIndentation: All }",
      "editor.formatOnSave": true,
      "editor.formatOnType": true,
      "editor.formatOnPaste": true

From 6276e4ec06b1d698cc3e0ca5e5d9dd9b57097b32 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sun, 24 May 2020 16:11:08 -0400
Subject: [PATCH 016/290] use cinttypes for size specific int type

---
 others/large_number.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/others/large_number.h b/others/large_number.h
index abc63b765..84d885f67 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -6,6 +6,7 @@
 #ifndef OTHERS_LARGE_NUMBER_H_
 #define OTHERS_LARGE_NUMBER_H_
 #include <cassert>
+#include <cinttypes>
 #include <cstring>
 #include <iostream>
 #include <type_traits>
@@ -21,9 +22,9 @@ class large_number {
 public:
     large_number() /**< initializer with value = 1 */ { _digits.push_back(1); }
 
-    large_number(unsigned long n) /**< initializer from an integer */
+    large_number(uint64_t n) /**< initializer from an integer */
     {
-        unsigned long carry = n;
+        uint64_t carry = n;
         do {
             add_digit(carry % 10);
             carry /= 10;

From b802dbe077faf117cce2203d1a5c33064a12c9e5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sun, 24 May 2020 16:24:41 -0400
Subject: [PATCH 017/290] code cleanup

---
 others/large_number.h | 471 +++++++++++++++++++++---------------------
 1 file changed, 231 insertions(+), 240 deletions(-)

diff --git a/others/large_number.h b/others/large_number.h
index 84d885f67..4f3851053 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -5,6 +5,7 @@
 
 #ifndef OTHERS_LARGE_NUMBER_H_
 #define OTHERS_LARGE_NUMBER_H_
+#include <algorithm>
 #include <cassert>
 #include <cinttypes>
 #include <cstring>
@@ -19,263 +20,253 @@
  * large number with long unsigned integers.
  **/
 class large_number {
-public:
-    large_number() /**< initializer with value = 1 */ { _digits.push_back(1); }
+ public:
+  /**< initializer with value = 1 */
+  large_number() { _digits.push_back(1); }
 
-    large_number(uint64_t n) /**< initializer from an integer */
-    {
-        uint64_t carry = n;
-        do {
-            add_digit(carry % 10);
-            carry /= 10;
-        } while (carry != 0);
+  /**< initializer from an integer */
+  explicit large_number(uint64_t n) {
+    uint64_t carry = n;
+    do {
+      add_digit(carry % 10);
+      carry /= 10;
+    } while (carry != 0);
+  }
+
+  /**< initializer from another large_number */
+  explicit large_number(const large_number &a) { _digits = a._digits; }
+
+  /**< initializer from a vector */
+  explicit large_number(const std::vector<unsigned char> &vec) {
+    _digits = vec;
+  }
+
+  /**< initializer from a string */
+  explicit large_number(const char *number_str) {
+    for (size_t i = strlen(number_str); i > 0; i--) {
+      unsigned char a = number_str[i - 1] - '0';
+      if (a >= 0 && a <= 9) _digits.push_back(a);
+    }
+  }
+
+  /**
+   * Function to check implementation
+   **/
+  static bool test() {
+    std::cout << "------ Checking `large_number` class implementations\t"
+              << std::endl;
+    large_number a(40);
+    // 1. test multiplication
+    a *= 10;
+    if (a != large_number(400)) {
+      std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
+      return false;
+    }
+    std::cout << "\tPassed 1/6...";
+    // 2. test compound addition with integer
+    a += 120;
+    if (a != large_number(520)) {
+      std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
+      return false;
+    }
+    std::cout << "\tPassed 2/6...";
+    // 3. test compound multiplication again
+    a *= 10;
+    if (a != large_number(5200)) {
+      std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
+      return false;
+    }
+    std::cout << "\tPassed 3/6...";
+    // 4. test increment (prefix)
+    ++a;
+    if (a != large_number(5201)) {
+      std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
+      return false;
+    }
+    std::cout << "\tPassed 4/6...";
+    // 5. test increment (postfix)
+    a++;
+    if (a != large_number(5202)) {
+      std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
+      return false;
+    }
+    std::cout << "\tPassed 5/6...";
+    // 6. test addition with another large number
+    a = a + large_number("7000000000000000000000000000000");
+    if (a != large_number("7000000000000000000000000005202")) {
+      std::cerr << "\tFailed 6/6 (" << a << "!=7000000000000000000000000005202)"
+                << std::endl;
+      return false;
+    }
+    std::cout << "\tPassed 6/6..." << std::endl;
+    return true;
+  }
+
+  /**
+   * add a digit at MSB to the large number
+   **/
+  void add_digit(unsigned int value) {
+    if (value > 9) {
+      std::cerr << "digit > 9!!\n";
+      exit(EXIT_FAILURE);
     }
 
-    large_number(
-        const large_number &a) /**< initializer from another large_number */
-    {
-        _digits = a._digits;
-    }
+    _digits.push_back(value);
+  }
 
-    large_number(
-        const std::vector<unsigned char> &vec) /**< initializer from a vector */
-    {
-        _digits = vec;
-    }
+  /**
+   * Get number of digits in the number
+   **/
+  const size_t num_digits() const { return _digits.size(); }
 
-    large_number(const char *number_str) /**< initializer from a string */
-    {
-        for (size_t i = strlen(number_str); i > 0; i--) {
-            unsigned char a = number_str[i - 1] - '0';
-            if (a >= 0 && a <= 9)
-                _digits.push_back(a);
-        }
-    }
+  /**
+   * operator over load to access the
+   * i^th digit conveniently and also
+   * assign value to it
+   **/
+  inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
 
-    /**
-     * Function to check implementation
-     **/
-    static bool test() {
-        std::cout << "------ Checking `large_number` class implementations\t"
-                  << std::endl;
-        large_number a(40);
-        // 1. test multiplication
-        a *= 10;
-        if (a != large_number(400)) {
-            std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
-            return false;
-        }
-        std::cout << "\tPassed 1/6...";
-        // 2. test compound addition with integer
-        a += 120;
-        if (a != large_number(520)) {
-            std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
-            return false;
-        }
-        std::cout << "\tPassed 2/6...";
-        // 3. test compound multiplication again
-        a *= 10;
-        if (a != large_number(5200)) {
-            std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
-            return false;
-        }
-        std::cout << "\tPassed 3/6...";
-        // 4. test increment (prefix)
-        ++a;
-        if (a != large_number(5201)) {
-            std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
-            return false;
-        }
-        std::cout << "\tPassed 4/6...";
-        // 5. test increment (postfix)
-        a++;
-        if (a != large_number(5202)) {
-            std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
-            return false;
-        }
-        std::cout << "\tPassed 5/6...";
-        // 6. test addition with another large number
-        a = a + large_number("7000000000000000000000000000000");
-        if (a != large_number("7000000000000000000000000005202")) {
-            std::cerr << "\tFailed 6/6 (" << a
-                      << "!=7000000000000000000000000005202)" << std::endl;
-            return false;
-        }
-        std::cout << "\tPassed 6/6..." << std::endl;
-        return true;
-    }
+  inline const unsigned char &operator[](size_t n) const {
+    return this->_digits[n];
+  }
 
-    /**
-     * add a digit at MSB to the large number
-     **/
-    void add_digit(unsigned int value) {
-        if (value > 9) {
-            std::cerr << "digit > 9!!\n";
-            exit(EXIT_FAILURE);
-        }
+  /**
+   * operator overload to compare two numbers
+   **/
+  friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
+    for (size_t i = a.num_digits(); i > 0; i--)
+      out << static_cast<int>(a[i - 1]);
+    return out;
+  }
 
-        _digits.push_back(value);
-    }
+  /**
+   * operator overload to compare two numbers
+   **/
+  friend bool operator==(large_number const &a, large_number const &b) {
+    size_t N = a.num_digits();
+    if (N != b.num_digits()) return false;
+    for (size_t i = 0; i < N; i++)
+      if (a[i] != b[i]) return false;
+    return true;
+  }
 
-    /**
-     * Get number of digits in the number
-     **/
-    const size_t num_digits() const { return _digits.size(); }
+  /**
+   * operator overload to compare two numbers
+   **/
+  friend bool operator!=(large_number const &a, large_number const &b) {
+    return !(a == b);
+  }
 
-    /**
-     * operator over load to access the
-     * i^th digit conveniently and also
-     * assign value to it
-     **/
-    inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
+  /**
+   * operator overload to increment (prefix)
+   **/
+  large_number &operator++() {
+    (*this) += 1;
+    return *this;
+  }
 
-    inline const unsigned char &operator[](size_t n) const {
-        return this->_digits[n];
-    }
+  /**
+   * operator overload to increment (postfix)
+   **/
+  large_number operator++(int) {
+    large_number tmp(_digits);
+    ++(*this);
+    return tmp;
+  }
 
-    /**
-     * operator overload to compare two numbers
-     **/
-    friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
-        for (size_t i = a.num_digits(); i > 0; i--)
-            out << static_cast<int>(a[i - 1]);
-        return out;
-    }
-
-    /**
-     * operator overload to compare two numbers
-     **/
-    friend bool operator==(large_number const &a, large_number const &b) {
-        size_t N = a.num_digits();
-        if (N != b.num_digits())
-            return false;
-        for (size_t i = 0; i < N; i++)
-            if (a[i] != b[i])
-                return false;
-        return true;
-    }
-
-    /**
-     * operator overload to compare two numbers
-     **/
-    friend bool operator!=(large_number const &a, large_number const &b) {
-        return !(a == b);
-    }
-
-    /**
-     * operator overload to increment (prefix)
-     **/
-    large_number &operator++() {
-        (*this) += 1;
-        return *this;
-    }
-
-    /**
-     * operator overload to increment (postfix)
-     **/
-    large_number operator++(int) {
-        large_number tmp(_digits);
-        ++(*this);
-        return tmp;
-    }
-
-    /**
-     * operator overload to add
-     **/
-    template <class T>
-    large_number &operator+=(T n) {
-        if (typeid(T) ==
-            typeid(large_number))  // if adding with another large_number
-        {
-            large_number *b = (large_number *)&n;
-            const size_t max_L = std::max(this->num_digits(), b->num_digits());
-            unsigned int carry = 0;
-            size_t i;
-            for (i = 0; i < max_L || carry != 0; i++) {
-                if (i < b->num_digits())
-                    carry += (*b)[i];
-                if (i < this->num_digits())
-                    carry += (*this)[i];
-                if (i < this->num_digits())
-                    (*this)[i] = carry % 10;
-                else
-                    this->add_digit(carry % 10);
-                carry /= 10;
-            }
-        } else if (std::is_integral<T>::value)
-            return (*this) += large_number(n);
+  /**
+   * operator overload to add
+   **/
+  template <class T>
+  large_number &operator+=(T n) {
+    // if adding with another large_number
+    if (typeid(T) == typeid(large_number)) {
+      large_number *b = static_cast<large_number *>(&n);
+      const size_t max_L = std::max(this->num_digits(), b->num_digits());
+      unsigned int carry = 0;
+      size_t i;
+      for (i = 0; i < max_L || carry != 0; i++) {
+        if (i < b->num_digits()) carry += (*b)[i];
+        if (i < this->num_digits()) carry += (*this)[i];
+        if (i < this->num_digits())
+          (*this)[i] = carry % 10;
         else
-            std::cerr << "Must be integer addition unsigned integer types."
-                      << std::endl;
-        return *this;
+          this->add_digit(carry % 10);
+        carry /= 10;
+      }
+    } else if (std::is_integral<T>::value) {
+      return (*this) += large_number(n);
+    } else {
+      std::cerr << "Must be integer addition unsigned integer types."
+                << std::endl;
+    }
+    return *this;
+  }
+
+  /**
+   * operator overload to perform addition
+   **/
+  template <class T>
+  friend large_number &operator+(const large_number &a, const T &b) {
+    a += b;
+    return a;
+  }
+
+  /**
+   * assignment operator
+   **/
+  void operator=(const large_number &b) { _digits = b._digits; }
+
+  /**
+   * operator overload to increment
+   **/
+  template <class T>
+  large_number &operator*=(const T n) {
+    static_assert(std::is_integral<T>::value,
+                  "Must be integer addition unsigned integer types.");
+    this->multiply(n);
+    return *this;
+  }
+
+  /**
+   * returns i^th digit as an ASCII character
+   **/
+  const char digit_char(size_t i) const {
+    return _digits[num_digits() - i - 1] + '0';
+  }
+
+ private:
+  /**
+   * multiply large number with another integer and
+   * store the result in the same large number
+   **/
+  template <class T>
+  void multiply(const T n) {
+    static_assert(std::is_integral<T>::value, "Can only have integer types.");
+    // assert(!(std::is_signed<T>::value)); //, "Implemented only for
+    // unsigned integer types.");
+
+    size_t i;
+    uint64_t carry = 0, temp;
+    for (i = 0; i < this->num_digits(); i++) {
+      temp = (*this)[i] * n;
+      temp += carry;
+      if (temp < 10) {
+        carry = 0;
+      } else {
+        carry = temp / 10;
+        temp = temp % 10;
+      }
+      (*this)[i] = temp;
     }
 
-    /**
-     * operator overload to perform addition
-     **/
-    template <class T>
-    friend large_number &operator+(large_number &a, const T &b) {
-        a += b;
-        return a;
+    while (carry != 0) {
+      this->add_digit(carry % 10);
+      carry /= 10;
     }
+  }
 
-    /**
-     * assignment operator
-     **/
-    void operator=(const large_number &b) { _digits = b._digits; }
-
-    /**
-     * operator overload to increment
-     **/
-    template <class T>
-    large_number &operator*=(const T n) {
-        static_assert(std::is_integral<T>::value,
-                      "Must be integer addition unsigned integer types.");
-        this->multiply(n);
-        return *this;
-    }
-
-    /**
-     * returns i^th digit as an ASCII character
-     **/
-    const char digit_char(size_t i) const {
-        return _digits[num_digits() - i - 1] + '0';
-    }
-
-private:
-    /**
-     * multiply large number with another integer and
-     * store the result in the same large number
-     **/
-    template <class T>
-    void multiply(const T n) {
-        static_assert(std::is_integral<T>::value,
-                      "Can only have integer types.");
-        // assert(!(std::is_signed<T>::value)); //, "Implemented only for
-        // unsigned integer types.");
-
-        size_t i;
-        unsigned long long carry = 0, temp;
-        for (i = 0; i < this->num_digits(); i++) {
-            temp = (*this)[i] * n;
-            temp += carry;
-            if (temp < 10)
-                carry = 0;
-            else {
-                carry = temp / 10;
-                temp = temp % 10;
-            }
-            (*this)[i] = temp;
-        }
-
-        while (carry != 0) {
-            this->add_digit(carry % 10);
-            carry /= 10;
-        }
-    };
-
-    std::vector<unsigned char>
-        _digits; /**< where individual digits are stored */
+  std::vector<unsigned char> _digits; /**< where individual digits are stored */
 };
 
 #endif  // OTHERS_LARGE_NUMBER_H_

From 58f77c404696402bc5b45174ad1f02baaedfda4b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sun, 24 May 2020 16:27:18 -0400
Subject: [PATCH 018/290] remove erroneous const from `+` operator

---
 others/large_number.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/others/large_number.h b/others/large_number.h
index 4f3851053..38d9125de 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -207,7 +207,7 @@ class large_number {
    * operator overload to perform addition
    **/
   template <class T>
-  friend large_number &operator+(const large_number &a, const T &b) {
+  friend large_number &operator+(large_number &a, const T &b) {
     a += b;
     return a;
   }

From 251c32d8b334779c0ac891422a2722d3ba4660fa Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Mon, 25 May 2020 11:03:30 -0400
Subject: [PATCH 019/290] Update .vscode/settings.json

removed additional comma in the JSON

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 .vscode/settings.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 5815b2666..4d291141b 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -64,7 +64,7 @@
           "valarray": "cpp",
           "algorithm": "cpp"
      },
-     "C_Cpp.clang_format_style": "{ BasedOnStyle: Google, UseTab: Never, IndentWidth: 4, TabWidth: 4,, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 80, AccessModifierOffset: -4, NamespaceIndentation: All }",
+     "C_Cpp.clang_format_style": "{ BasedOnStyle: Google, UseTab: Never, IndentWidth: 4, TabWidth: 4, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 80, AccessModifierOffset: -4, NamespaceIndentation: All }",
      "editor.formatOnSave": true,
      "editor.formatOnType": true,
      "editor.formatOnPaste": true

From 1f07064a78801208e257ac4113db89651cfd3ba9 Mon Sep 17 00:00:00 2001
From: Amit Kumar <offamitkumar@gmail.com>
Date: Mon, 25 May 2020 20:47:55 +0530
Subject: [PATCH 020/290] feat : find maximum flow in a graph (#791)

* feat : find maximum flow in a graph

* updated : find maximum flow in a graph

* updated name - conventions

* updated some suitable namings
---
 ...th_ford_fulkerson_and_edmond_karp_algo.cpp | 122 ++++++++++++++++++
 1 file changed, 122 insertions(+)
 create mode 100644 graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp

diff --git a/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp b/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
new file mode 100644
index 000000000..ee394d9f0
--- /dev/null
+++ b/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
@@ -0,0 +1,122 @@
+/*
+ * Author: Amit Kumar
+ * Created: May 24, 2020
+ * Copyright: 2020, Open-Source
+ * Last Modified: May 25, 2020
+ */
+#include <iostream>
+#include <queue>
+#include <tuple>
+#include <algorithm>
+#include <bitset>
+#include <limits>
+#include <cstring>
+#include <vector>
+#include <utility>
+// std::max capacity of node in graph
+const int MAXN = 505;
+class Graph {
+    int residual_capacity[MAXN][MAXN];
+    int capacity[MAXN][MAXN];  //  used while checking the flow of edge
+    int total_nodes;
+    int total_edges, source, sink;
+    int parent[MAXN];
+    std::vector <std::tuple <int, int, int> >edge_participated;
+    std::bitset <MAXN> visited;
+    int max_flow = 0;
+    bool bfs(int source, int sink) {  //  to find the augmented - path
+        memset(parent, -1, sizeof(parent));
+        visited.reset();
+        std::queue<int>q;
+        q.push(source);
+        bool is_path_found = false;
+        while (q.empty() == false && is_path_found == false) {
+            int current_node = q.front();
+            visited.set(current_node);
+            q.pop();
+            for (int i = 0; i < total_nodes; ++i) {
+                if (residual_capacity[current_node][i] > 0 && !visited[i]) {
+                    visited.set(i);
+                    parent[i] = current_node;
+                    if (i == sink) {
+                        return true;
+                    }
+                    q.push(i);
+                }
+            }
+        }
+        return false;
+    }
+
+ public:
+    Graph() {
+        memset(residual_capacity, 0, sizeof(residual_capacity));
+    }
+    void set_graph(void) {
+        std::cin >> total_nodes >> total_edges >> source >> sink;
+        for (int start, destination, capacity_, i = 0; i < total_edges; ++i) {
+            std::cin >> start >> destination >> capacity_;
+            residual_capacity[start][destination] = capacity_;
+            capacity[start][destination] = capacity_;
+        }
+    }
+    void ford_fulkerson(void) {
+        while (bfs(source, sink)) {
+            int current_node = sink;
+            int flow = std::numeric_limits<int>::max();
+            while (current_node != source) {
+                int parent_ = parent[current_node];
+                flow = std::min(flow, residual_capacity[parent_][current_node]);
+                current_node = parent_;
+            }
+            current_node = sink;
+            max_flow += flow;
+            while ( current_node != source ) {
+                int parent_ = parent[current_node];
+                residual_capacity[parent_][current_node] -= flow;
+                residual_capacity[current_node][parent_] += flow;
+                current_node = parent_;
+            }
+        }
+    }
+    void print_flow_info(void) {
+        for (int i = 0; i < total_nodes; ++i) {
+            for (int j = 0; j < total_nodes; ++j) {
+                if (capacity[i][j] &&
+                        residual_capacity[i][j] < capacity[i][j]) {
+                    edge_participated.push_back(
+                            std::make_tuple(i, j,
+                                capacity[i][j]-residual_capacity[i][j]));
+                }
+            }
+        }
+        std::cout << "\nNodes : " << total_nodes
+            << "\nMax flow: " << max_flow
+            << "\nEdge present in flow: " << edge_participated.size()
+            << '\n';
+        std::cout<< "\nSource\tDestination\tCapacity\total_nodes";
+        for (auto&edge_data : edge_participated) {
+            int source, destination, capacity_;
+            std::tie(source, destination, capacity_) = edge_data;
+            std::cout << source << "\t" << destination << "\t\t"
+                      << capacity_ <<'\t';
+        }
+    }
+};
+int main(void) {
+    /*
+       Input Graph: (for testing )
+        4 5 0 3
+        0 1 10
+        1 2 1
+        1 3 1
+        0 2 1
+        2 3 10
+     */
+    Graph graph;
+    graph.set_graph();
+    graph.ford_fulkerson();
+    graph.print_flow_info();
+    return 0;
+}
+

From 6b55d4472f4b1685918e191a3d05a680ab00f7fd Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Mon, 25 May 2020 15:18:11 +0000
Subject: [PATCH 021/290] updating DIRECTORY.md

---
 DIRECTORY.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index ddbfd06d8..9e36309dc 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -83,6 +83,7 @@
   * [Kosaraju](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/kosaraju.cpp)
   * [Kruskal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/Kruskal.cpp)
   * [Lca](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/lca.cpp)
+  * [Max Flow With Ford Fulkerson And Edmond Karp Algo](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp)
   * [Prim](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/prim.cpp)
   * [Topological-Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/Topological-Sort.cpp)
   * [Topological Sort By Kahns Algo](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/topological_sort_by_kahns_algo.cpp)

From 64f07fc21a985c403b5295f5bef0ae5401c9efbd Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 21:43:52 -0400
Subject: [PATCH 022/290] initial cmake

---
 CMakeLists.txt | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 000000000..f98109382
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,75 @@
+cmake_minimum_required(VERSION 3.3)
+project(Algorithms_in_C
+    LANGUAGES C CXX
+    VERSION 1.0.0
+    DESCRIPTION "Set of algorithms implemented in C."
+)
+
+option(USE_OPENMP "flag to use OpenMP for multithreading" ON)
+
+cmake_policy(SET CMP0054 NEW)
+cmake_policy(SET CMP0057 NEW)
+find_package(Doxygen OPTIONAL_COMPONENTS dot dia)
+if(DOXYGEN_FOUND)
+    set(DOXYGEN_GENERATE_MAN NO)
+    set(DOXYGEN_USE_MATHJAX YES)
+    set(DOXYGEN_GENERATE_HTML YES)
+    set(DOXYGEN_INLINE_SOURCES YES)
+    set(DOXYGEN_CREATE_SUBDIRS YES)
+    set(DOCYGEN_GENERATE_TREEVIEW YES)
+    set(DOXYGEN_STRIP_CODE_COMMENTS NO)
+    set(DOXYGEN_OPTIMIZE_OUTPUT_FOR_C YES)
+    set(DOXYGEN_MATHJAX_RELPATH "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-MML-AM_CHTML")
+    if(Doxygen_dot_FOUND)
+        set(DOXYGEN_HAVE_DOT YES)
+        set(DOXYGEN_CALL_GRAPH YES)
+        set(DOXYGEN_INTERACTIVE_SVG YES)
+        set(DOXYGEN_DOT_IMAGE_FORMAT "svg")
+    endif()
+
+    doxygen_add_docs(
+        doc
+        ${PROJECT_SOURCE_DIR}
+        COMMENT "Generate documentation"
+    )
+endif()
+
+function(function_timer)
+    set(CMAKE_BUILD_TYPE "Release")         # This is local to function
+    add_subdirectory(function_timer EXCLUDE_FROM_ALL)
+endfunction()
+
+function_timer()
+
+include_directories(function_timer/include)
+# link_libraries(function_timer)
+# include_directories(${CMAKE_BINARY_DIR}/include)
+# link_directories(${CMAKE_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE})
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+if(MSVC)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+    add_compile_options(/Za)
+endif(MSVC)
+
+add_subdirectory(conversions)
+add_subdirectory(misc)
+add_subdirectory(project_euler)
+add_subdirectory(sorting)
+add_subdirectory(searching)
+add_subdirectory(numerical_methods)
+
+if(USE_OPENMP)
+    find_package(OpenMP)
+    if (OpenMP_C_FOUND)
+        message(STATUS "Building with OpenMP Multithreading.")
+    else()
+        message(STATUS "No OpenMP found, no multithreading.")
+    endif()
+endif()
+
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)

From 0e3a57ab3fdf9bf11a4dd9c3b575656ba50decc3 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:13:08 -0400
Subject: [PATCH 023/290] ignore build directory

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index ed3934e45..12318c6cd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,5 @@
 a.out
 *.out
 *.app
+
+build/
\ No newline at end of file

From 412d3ff1a2fc491e4c8e0b05db814c186bdf7dc4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:13:39 -0400
Subject: [PATCH 024/290] file rename to standards

---
 math/{primes_up_to_10^8.cpp => primes_up_to_billion.cpp} | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)
 rename math/{primes_up_to_10^8.cpp => primes_up_to_billion.cpp} (79%)

diff --git a/math/primes_up_to_10^8.cpp b/math/primes_up_to_billion.cpp
similarity index 79%
rename from math/primes_up_to_10^8.cpp
rename to math/primes_up_to_billion.cpp
index db9b56cab..d8f5a9f9d 100644
--- a/math/primes_up_to_10^8.cpp
+++ b/math/primes_up_to_billion.cpp
@@ -1,12 +1,12 @@
-#include<iostream>
 #include <cstring>
+#include <iostream>
 
 char prime[100000000];
 
 void Sieve(int64_t n) {
     memset(prime, '1', sizeof(prime));  // intitize '1' to every index
-    prime[0] = '0';  // 0 is not prime
-    prime[1] = '0';  // 1 is not prime
+    prime[0] = '0';                     // 0 is not prime
+    prime[1] = '0';                     // 1 is not prime
     for (int p = 2; p * p <= n; p++) {
         if (prime[p] == '1') {
             for (int i = p * p; i <= n; i += p)
@@ -15,7 +15,6 @@ void Sieve(int64_t n) {
     }
 }
 
-
 int main() {
     Sieve(100000000);
     int64_t n;

From 260ba8d3a46e76b8d319c96b23983c9c2d93d046 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:13:52 -0400
Subject: [PATCH 025/290] syntax correction

---
 math/fibonacci.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index 1c07cd93f..e82875da3 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -1,5 +1,5 @@
-#include <iostream>
 #include <cassert>
+#include <iostream>
 
 /* Calculate the the value on Fibonacci's sequence given an
 integer as input
@@ -7,14 +7,13 @@ Fibonacci =  0, 1, 1, 2, 3, 5,
              8, 13, 21, 34, 55,
              89, 144, ...       */
 
-int fibonacci(uint n) {
+int fibonacci(unsigned int n) {
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
-    if (n <= 1)
-        return n;
+    if (n <= 1) return n;
 
     /* Add the last 2 values of the sequence to get next */
-    return fibonacci(n-1) + fibonacci(n-2);
+    return fibonacci(n - 1) + fibonacci(n - 2);
 }
 
 int main() {

From a1663277c76e8d814a745a596f864c2e1fdd9080 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:51:18 -0400
Subject: [PATCH 026/290] cherry pick changes from "cmake branch"


From 8207c776ebdbd3a77018651223e37780a151cc2a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:13:52 -0400
Subject: [PATCH 027/290] syntax correction

(cherry picked from commit 260ba8d3a46e76b8d319c96b23983c9c2d93d046)
---
 math/fibonacci.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index 1c07cd93f..e82875da3 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -1,5 +1,5 @@
-#include <iostream>
 #include <cassert>
+#include <iostream>
 
 /* Calculate the the value on Fibonacci's sequence given an
 integer as input
@@ -7,14 +7,13 @@ Fibonacci =  0, 1, 1, 2, 3, 5,
              8, 13, 21, 34, 55,
              89, 144, ...       */
 
-int fibonacci(uint n) {
+int fibonacci(unsigned int n) {
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
-    if (n <= 1)
-        return n;
+    if (n <= 1) return n;
 
     /* Add the last 2 values of the sequence to get next */
-    return fibonacci(n-1) + fibonacci(n-2);
+    return fibonacci(n - 1) + fibonacci(n - 2);
 }
 
 int main() {

From b36322c629809375de3abc30d48479efa4acddbf Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:13:39 -0400
Subject: [PATCH 028/290] file rename to standards

(cherry picked from commit 412d3ff1a2fc491e4c8e0b05db814c186bdf7dc4)
---
 math/{primes_up_to_10^8.cpp => primes_up_to_billion.cpp} | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)
 rename math/{primes_up_to_10^8.cpp => primes_up_to_billion.cpp} (79%)

diff --git a/math/primes_up_to_10^8.cpp b/math/primes_up_to_billion.cpp
similarity index 79%
rename from math/primes_up_to_10^8.cpp
rename to math/primes_up_to_billion.cpp
index db9b56cab..d8f5a9f9d 100644
--- a/math/primes_up_to_10^8.cpp
+++ b/math/primes_up_to_billion.cpp
@@ -1,12 +1,12 @@
-#include<iostream>
 #include <cstring>
+#include <iostream>
 
 char prime[100000000];
 
 void Sieve(int64_t n) {
     memset(prime, '1', sizeof(prime));  // intitize '1' to every index
-    prime[0] = '0';  // 0 is not prime
-    prime[1] = '0';  // 1 is not prime
+    prime[0] = '0';                     // 0 is not prime
+    prime[1] = '0';                     // 1 is not prime
     for (int p = 2; p * p <= n; p++) {
         if (prime[p] == '1') {
             for (int i = p * p; i <= n; i += p)
@@ -15,7 +15,6 @@ void Sieve(int64_t n) {
     }
 }
 
-
 int main() {
     Sieve(100000000);
     int64_t n;

From 1e5b9f842da6d3d25ef608f5fbdaf54f38631db8 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:13:08 -0400
Subject: [PATCH 029/290] ignore build directory

(cherry picked from commit 0e3a57ab3fdf9bf11a4dd9c3b575656ba50decc3)
---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index ed3934e45..12318c6cd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,5 @@
 a.out
 *.out
 *.app
+
+build/
\ No newline at end of file

From baea3b07c1588361ed1a514d39a2979c56ff4a6a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 22:56:38 -0400
Subject: [PATCH 030/290] major corrections in the files -  bad CPPLINT and
 non-compilable codes

---
 .../Bisection_method.CPP                      | 75 ++++++++-----------
 .../Newton_Raphson.CPP                        | 53 -------------
 .../Secant_method.CPP                         | 70 +++++++----------
 .../newton_raphson_method.cpp                 | 41 ++++++++++
 .../successive_approximation.CPP              | 63 +++++++---------
 math/prime_factorization.cpp                  | 46 +++++-------
 6 files changed, 145 insertions(+), 203 deletions(-)
 delete mode 100644 computer_oriented_statistical_methods/Newton_Raphson.CPP
 create mode 100644 computer_oriented_statistical_methods/newton_raphson_method.cpp

diff --git a/computer_oriented_statistical_methods/Bisection_method.CPP b/computer_oriented_statistical_methods/Bisection_method.CPP
index 717987321..266083de1 100644
--- a/computer_oriented_statistical_methods/Bisection_method.CPP
+++ b/computer_oriented_statistical_methods/Bisection_method.CPP
@@ -1,53 +1,40 @@
-#include <iostream.h>
-#include <conio.h>
-#include <math.h>
+#include <cmath>
+#include <iostream>
 
-float eq(float i)
-{
-	return (pow(i, 3) - (4 * i) - 9); // original equation
+float eq(float i) {
+    return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
-void main()
-{
-	float a, b, x, z;
-	clrscr();
-	for (int i = 0; i < 100; i++)
-	{
-		z = eq(i);
-		if (z >= 0)
-		{
-			b = i;
-			a = --i;
-			goto START;
-		}
-	}
+int main() {
+    float a, b, x, z;
 
-START:
+    for (int i = 0; i < 100; i++) {
+        z = eq(i);
+        if (z >= 0) {
+            b = i;
+            a = --i;
+            break;
+        }
+    }
 
-	cout << "\nFirst initial: " << a;
-	cout << "\nSecond initial: " << b;
-	for (i = 0; i < 100; i++)
-	{
-		x = (a + b) / 2;
-		z = eq(x);
-		cout << "\n\nz: " << z << "\t[" << a << " , " << b << " | Bisect: " << x << "]";
+    std::cout << "\nFirst initial: " << a;
+    std::cout << "\nSecond initial: " << b;
+    for (int i = 0; i < 100; i++) {
+        x = (a + b) / 2;
+        z = eq(x);
+        std::cout << "\n\nz: " << z << "\t[" << a << " , " << b
+                  << " | Bisect: " << x << "]";
 
-		if (z < 0)
-		{
-			a = x;
-		}
-		else
-		{
-			b = x;
-		}
+        if (z < 0) {
+            a = x;
+        } else {
+            b = x;
+        }
 
-		if (z > 0 && z < 0.0009) // stoping criteria
-		{
-			goto END;
-		}
-	}
+        if (z > 0 && z < 0.0009)  // stoping criteria
+            break;
+    }
 
-END:
-	cout << "\n\nRoot: " << x;
-	getch();
+    std::cout << "\n\nRoot: " << x;
+    return 0;
 }
diff --git a/computer_oriented_statistical_methods/Newton_Raphson.CPP b/computer_oriented_statistical_methods/Newton_Raphson.CPP
deleted file mode 100644
index 183a78daf..000000000
--- a/computer_oriented_statistical_methods/Newton_Raphson.CPP
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <iostream.h>
-#include <conio.h>
-#include <math.h>
-
-float eq(float i)
-{
-	return (pow(i, 3) - (4 * i) - 9); // original equation
-}
-float eq_der(float i)
-{
-	return ((3 * pow(i, 2)) - 4); // derivative of equation
-}
-
-void main()
-{
-	float a, b, z, c, m, n;
-	clrscr();
-	for (int i = 0; i < 100; i++)
-	{
-		z = eq(i);
-		if (z >= 0)
-		{
-			b = i;
-			a = --i;
-			goto START;
-		}
-	}
-
-START:
-
-	cout << "\nFirst initial: " << a;
-	cout << "\nSecond initial: " << b;
-	c = (a + b) / 2;
-
-	for (i = 0; i < 100; i++)
-	{
-		float h;
-		m = eq(c);
-		n = eq_der(c);
-
-		z = c - (m / n);
-		c = z;
-
-		if (m > 0 && m < 0.009) // stoping criteria
-		{
-			goto END;
-		}
-	}
-
-END:
-	cout << "\n\nRoot: " << z;
-	getch();
-}
diff --git a/computer_oriented_statistical_methods/Secant_method.CPP b/computer_oriented_statistical_methods/Secant_method.CPP
index b897e9184..bd805ed36 100644
--- a/computer_oriented_statistical_methods/Secant_method.CPP
+++ b/computer_oriented_statistical_methods/Secant_method.CPP
@@ -1,49 +1,37 @@
-#include <iostream.h>
-#include <conio.h>
-#include <math.h>
+#include <cmath>
+#include <iostream>
 
-float eq(float i)
-{
-	return (pow(i, 3) - (4 * i) - 9); // original equation
+float eq(float i) {
+    return (pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
-void main()
-{
-	float a, b, z, c, m, n;
-	clrscr();
-	for (int i = 0; i < 100; i++)
-	{
-		z = eq(i);
-		if (z >= 0)
-		{
-			b = i;
-			a = --i;
-			goto START;
-		}
-	}
+int main() {
+    float a, b, z, c, m, n;
+    for (int i = 0; i < 100; i++) {
+        z = eq(i);
+        if (z >= 0) {
+            b = i;
+            a = --i;
+            break;
+        }
+    }
 
-START:
+    std::cout << "\nFirst initial: " << a;
+    std::cout << "\nSecond initial: " << b;
+    for (int i = 0; i < 100; i++) {
+        float h, d;
+        m = eq(a);
+        n = eq(b);
 
-	cout << "\nFirst initial: " << a;
-	cout << "\nSecond initial: " << b;
-	for (i = 0; i < 100; i++)
-	{
-		float h, d;
-		m = eq(a);
-		n = eq(b);
+        c = ((a * n) - (b * m)) / (n - m);
+        a = b;
+        b = c;
 
-		c = ((a * n) - (b * m)) / (n - m);
-		a = b;
-		b = c;
+        z = eq(c);
+        if (z > 0 && z < 0.09)  // stoping criteria
+            break;
+    }
 
-		z = eq(c);
-		if (z > 0 && z < 0.09) // stoping criteria
-		{
-			goto END;
-		}
-	}
-
-END:
-	cout << "\n\nRoot: " << c;
-	getch();
+    std::cout << "\n\nRoot: " << c;
+    return 0;
 }
diff --git a/computer_oriented_statistical_methods/newton_raphson_method.cpp b/computer_oriented_statistical_methods/newton_raphson_method.cpp
new file mode 100644
index 000000000..a2a57768e
--- /dev/null
+++ b/computer_oriented_statistical_methods/newton_raphson_method.cpp
@@ -0,0 +1,41 @@
+#include <cmath>
+#include <iostream>
+
+float eq(float i) {
+    return (std::pow(i, 3) - (4 * i) - 9);  // original equation
+}
+float eq_der(float i) {
+    return ((3 * std::pow(i, 2)) - 4);  // derivative of equation
+}
+
+int main() {
+    float a, b, z, c, m, n;
+
+    for (int i = 0; i < 100; i++) {
+        z = eq(i);
+        if (z >= 0) {
+            b = i;
+            a = --i;
+            break;
+        }
+    }
+
+    std::cout << "\nFirst initial: " << a;
+    std::cout << "\nSecond initial: " << b;
+    c = (a + b) / 2;
+
+    for (int i = 0; i < 100; i++) {
+        float h;
+        m = eq(c);
+        n = eq_der(c);
+
+        z = c - (m / n);
+        c = z;
+
+        if (m > 0 && m < 0.009)  // stoping criteria
+            break;
+    }
+
+    std::cout << "\n\nRoot: " << z << std::endl;
+    return 0;
+}
diff --git a/computer_oriented_statistical_methods/successive_approximation.CPP b/computer_oriented_statistical_methods/successive_approximation.CPP
index b42ab8f8c..85c42c9fb 100644
--- a/computer_oriented_statistical_methods/successive_approximation.CPP
+++ b/computer_oriented_statistical_methods/successive_approximation.CPP
@@ -1,37 +1,28 @@
-#include <conio.h>
-#include <iostream.h>
-#include <math.h>
-float eq(float y)
-{
-	return ((3 * y) - (cos(y)) - 2);
+
+#include <cmath>
+#include <iostream>
+
+float eq(float y) { return ((3 * y) - (cos(y)) - 2); }
+float eqd(float y) { return ((0.5) * ((cos(y)) + 2)); }
+
+int main() {
+    float y, x1, x2, x3, sum, s, a, f1, f2, gd;
+    int i, n;
+
+    for (i = 0; i < 10; i++) {
+        sum = eq(y);
+        std::cout << "value of equation at " << i << " " << sum << "\n";
+        y++;
+    }
+    std::cout << "enter the x1->";
+    std::cin >> x1;
+    std::cout << "enter the no iteration to perform->\n";
+    std::cin >> n;
+
+    for (i = 0; i <= n; i++) {
+        x2 = eqd(x1);
+        std::cout << "\nenter the x2->" << x2;
+        x1 = x2;
+    }
+    return 0;
 }
-float eqd(float y)
-{
-	return ((0.5) * ((cos(y)) + 2));
-}
-
-void main()
-{
-	float y, x1, x2, x3, sum, s, a, f1, f2, gd;
-	int i, n;
-
-	clrscr();
-	for (i = 0; i < 10; i++)
-	{
-		sum = eq(y);
-		cout << "value of equation at " << i << " " << sum << "\n";
-		y++;
-	}
-	cout << "enter the x1->";
-	cin >> x1;
-	cout << "enter the no iteration to perform->\n";
-	cin >> n;
-
-	for (i = 0; i <= n; i++)
-	{
-		x2 = eqd(x1);
-		cout << "\nenter the x2->" << x2;
-		x1 = x2;
-	}
-	getch();
-}
\ No newline at end of file
diff --git a/math/prime_factorization.cpp b/math/prime_factorization.cpp
index 822cad332..bd1b99d97 100644
--- a/math/prime_factorization.cpp
+++ b/math/prime_factorization.cpp
@@ -1,67 +1,56 @@
+#include <algorithm>
+#include <cstring>
 #include <iostream>
 #include <vector>
-#include <algorithm>
 using namespace std;
 
-// Declaring variables for maintaing prime numbers and to check whether a number is prime or not
+// Declaring variables for maintaing prime numbers and to check whether a number
+// is prime or not
 bool isprime[1000006];
 vector<int> prime_numbers;
 vector<pair<int, int>> factors;
 
 // Calculating prime number upto a given range
-void SieveOfEratosthenes(int N)
-{
+void SieveOfEratosthenes(int N) {
     // initializes the array isprime
     memset(isprime, true, sizeof isprime);
 
-    for (int i = 2; i <= N; i++)
-    {
-        if (isprime[i])
-        {
-            for (int j = 2 * i; j <= N; j += i)
-                isprime[j] = false;
+    for (int i = 2; i <= N; i++) {
+        if (isprime[i]) {
+            for (int j = 2 * i; j <= N; j += i) isprime[j] = false;
         }
     }
 
-    for (int i = 2; i <= N; i++)
-    {
-        if (isprime[i])
-            prime_numbers.push_back(i);
+    for (int i = 2; i <= N; i++) {
+        if (isprime[i]) prime_numbers.push_back(i);
     }
 }
 
 // Prime factorization of a number
-void prime_factorization(int num)
-{
-
+void prime_factorization(int num) {
     int number = num;
 
-    for (int i = 0; prime_numbers[i] <= num; i++)
-    {
+    for (int i = 0; prime_numbers[i] <= num; i++) {
         int count = 0;
 
         // termination condition
-        if (number == 1)
-        {
+        if (number == 1) {
             break;
         }
 
-        while (number % prime_numbers[i] == 0)
-        {
+        while (number % prime_numbers[i] == 0) {
             count++;
             number = number / prime_numbers[i];
         }
 
-        if (count)
-            factors.push_back(make_pair(prime_numbers[i], count));
+        if (count) factors.push_back(make_pair(prime_numbers[i], count));
     }
 }
 
 /*
     I added a simple UI.
 */
-int main()
-{
+int main() {
     int num;
     cout << "\t\tComputes the prime factorization\n\n";
     cout << "Type in a number: ";
@@ -72,8 +61,7 @@ int main()
     prime_factorization(num);
 
     // Prime factors with their powers in the given number in new line
-    for (auto it : factors)
-    {
+    for (auto it : factors) {
         cout << it.first << " " << it.second << endl;
     }
 

From ef24ae3a09a0db7a8988ddf9fcaff985e2d7d43f Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 02:57:04 +0000
Subject: [PATCH 031/290] updating DIRECTORY.md

---
 DIRECTORY.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 9e36309dc..17cd5f5c6 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -13,7 +13,7 @@
   * [Bisection Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Bisection_method.CPP)
   * [False-Position](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/false-position.cpp)
   * [Gaussian Elimination](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Gaussian_elimination.cpp)
-  * [Newton Raphson](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Newton_Raphson.CPP)
+  * [Newton Raphson Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/newton_raphson_method.cpp)
   * [Ordinary Least Squares Regressor](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp)
   * [Secant Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Secant_method.CPP)
   * [Successive Approximation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/successive_approximation.CPP)
@@ -116,7 +116,7 @@
   * [Power For Huge Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/power_for_huge_numbers.cpp)
   * [Prime Factorization](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/prime_factorization.cpp)
   * [Prime Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/prime_numbers.cpp)
-  * [Primes Up To 10^8](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/primes_up_to_10^8.cpp)
+  * [Primes Up To Billion](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/primes_up_to_billion.cpp)
   * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sieve_of_eratosthenes.cpp)
   * [Sqrt Double](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sqrt_double.cpp)
 

From 4e8a2f715197b92879cf599d9073578b940ab9af Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 23:12:12 -0400
Subject: [PATCH 032/290] non compiling and illegible code removed

---
 others/Strassen Matrix Multiplication.cpp | 56 -----------------------
 1 file changed, 56 deletions(-)
 delete mode 100644 others/Strassen Matrix Multiplication.cpp

diff --git a/others/Strassen Matrix Multiplication.cpp b/others/Strassen Matrix Multiplication.cpp
deleted file mode 100644
index 85b627763..000000000
--- a/others/Strassen Matrix Multiplication.cpp	
+++ /dev/null
@@ -1,56 +0,0 @@
-#include <iostream>
-using namespace std;
-
-Multiply(int A[][], int B[][], int n)
-{
-	if (n == 2)
-	{
-		int p1 = (a[0][0] + a[1][1]) * (b[0][0] + b[1][1]);
-		int p2 = (a[1][0] + a[1][1]) * b[0][0];
-		int p3 = a[0][0] * (b[0][1] - b[1][1]);
-		int p4 = a[1][1] * (b[1][0] - b[0][0]);
-		int p5 = (a[0][0] + a[0][1]) * b[1][1];
-		int p6 = (a[1][0] - a[0][0]) * (b[0][0] + b[0][1]);
-		int p7 = (a[0][1] - a[1][1]) * (b[1][0] + b[1][1]);
-
-		int c[n][n];
-		c[0][0] = p1 + p4 - p5 + p7;
-		c[0][1] = p3 + p5;
-		c[1][0] = p2 + p4;
-		c[1][1] = p1 - p2 + p3 + p6;
-
-		return c[][];
-	}
-	else
-	{
-	}
-}
-
-int main()
-{
-	int p, q, r, s;
-	cout << "Enter the dimensions of Matrices";
-	cin >> n;
-	int A[n][n], ;
-	int B[n][n], ;
-	cout << "Enter the elements of Matrix A";
-	for (int i = 0; i < n; i++)
-	{
-		for (int j = 0; j < n; j++)
-		{
-			cin >> A[i][j];
-		}
-	}
-
-	cout << "Enter the elements of Matrix B";
-	for (int i = 0; i < n; i++)
-	{
-		for (int j = 0; j < n; j++)
-		{
-			cin >> B[i][j];
-		}
-	}
-
-	Multiply(A, B, n);
-	return 0;
-}
\ No newline at end of file

From 120fe06fcb0d75c944c9453d703a20ce91e46e80 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 23:13:26 -0400
Subject: [PATCH 033/290] files renamed to standard - without spaces and made
 CPPLINT compatible

---
 others/GCD_of_n_numbers.cpp                   |  41 ++++---
 ...al To Binary.cpp => decimal_to_binary.cpp} |   0
 ...ecimal .cpp => decimal_to_hexadecimal.cpp} |   0
 ...meral.cpp => decimal_to_roman_numeral.cpp} |   0
 others/fibonacci.cpp                          |  42 -------
 others/fibonacci_fast.cpp                     |  37 ++++++
 others/matrix_exponentiation.cpp              |  14 +--
 ... Matching.cpp => paranthesis_matching.cpp} |   0
 others/pascal_triangle.cpp                    |  96 +++++++---------
 ...{Primality Test.cpp => primality_test.cpp} |   0
 .../{Sparse matrix.cpp => sparse_matrix.cpp}  |   0
 ...ing Fibonacci.cpp => string_fibonacci.cpp} |   0
 ...{Tower of Hanoi.cpp => tower_of_hanoi.cpp} |   0
 sorting/shell_sort2.cpp                       | 105 ++++++++++++++++++
 14 files changed, 211 insertions(+), 124 deletions(-)
 rename others/{Decimal To Binary.cpp => decimal_to_binary.cpp} (100%)
 rename others/{Decimal To Hexadecimal .cpp => decimal_to_hexadecimal.cpp} (100%)
 rename others/{Decimal to Roman Numeral.cpp => decimal_to_roman_numeral.cpp} (100%)
 delete mode 100644 others/fibonacci.cpp
 create mode 100644 others/fibonacci_fast.cpp
 rename others/{Paranthesis Matching.cpp => paranthesis_matching.cpp} (100%)
 rename others/{Primality Test.cpp => primality_test.cpp} (100%)
 rename others/{Sparse matrix.cpp => sparse_matrix.cpp} (100%)
 rename others/{String Fibonacci.cpp => string_fibonacci.cpp} (100%)
 rename others/{Tower of Hanoi.cpp => tower_of_hanoi.cpp} (100%)
 create mode 100644 sorting/shell_sort2.cpp

diff --git a/others/GCD_of_n_numbers.cpp b/others/GCD_of_n_numbers.cpp
index 8158052f8..b592e5931 100644
--- a/others/GCD_of_n_numbers.cpp
+++ b/others/GCD_of_n_numbers.cpp
@@ -1,23 +1,22 @@
-//This program aims at calculating the GCD of n numbers by division method
+// This program aims at calculating the GCD of n numbers by division method
 #include <iostream>
-using namepsace std;
-int main()
-{
-  cout << "Enter value of n:" << endl;
-  cin >> n;
-  int a[n];
-  int i, j, gcd;
-  cout << "Enter the n numbers:" << endl;
-  for (i = 0; i < n; i++)
-    cin >> a[i];
-  j = 1; //to access all elements of the array starting from 1
-  gcd = a[0];
-  while (j < n)
-  {
-    if (a[j] % gcd == 0) //value of gcd is as needed so far
-      j++;               //so we check for next element
-    else
-      gcd = a[j] % gcd; //calculating GCD by division method
-  }
-  cout << "GCD of entered n numbers:" << gcd;
+
+int main() {
+    int n;
+    std::cout << "Enter value of n:" << std::endl;
+    std::cin >> n;
+    int a[n];
+    int i, j, gcd;
+    std::cout << "Enter the n numbers:" << std::endl;
+    for (i = 0; i < n; i++) std::cin >> a[i];
+    j = 1;  // to access all elements of the array starting from 1
+    gcd = a[0];
+    while (j < n) {
+        if (a[j] % gcd == 0)  // value of gcd is as needed so far
+            j++;              // so we check for next element
+        else
+            gcd = a[j] % gcd;  // calculating GCD by division method
+    }
+    std::cout << "GCD of entered n numbers:" << gcd;
+    return 0;
 }
diff --git a/others/Decimal To Binary.cpp b/others/decimal_to_binary.cpp
similarity index 100%
rename from others/Decimal To Binary.cpp
rename to others/decimal_to_binary.cpp
diff --git a/others/Decimal To Hexadecimal .cpp b/others/decimal_to_hexadecimal.cpp
similarity index 100%
rename from others/Decimal To Hexadecimal .cpp
rename to others/decimal_to_hexadecimal.cpp
diff --git a/others/Decimal to Roman Numeral.cpp b/others/decimal_to_roman_numeral.cpp
similarity index 100%
rename from others/Decimal to Roman Numeral.cpp
rename to others/decimal_to_roman_numeral.cpp
diff --git a/others/fibonacci.cpp b/others/fibonacci.cpp
deleted file mode 100644
index 87ccda6d3..000000000
--- a/others/fibonacci.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-//An efficient way to calculate nth fibonacci number faster and simpler than O(nlogn) method of matrix exponentiation
-//This works by using both recursion and dynamic programming.
-//as 93rd fibonacci exceeds 19 digits, which cannot be stored in a single long long variable, we can only use it till 92nd fibonacci
-//we can use it for 10000th fibonacci etc, if we implement bigintegers.
-//This algorithm works with the fact that nth fibonacci can easily found if we have already found n/2th or (n+1)/2th fibonacci
-//It is a property of fibonacci similar to matrix exponentiation.
-
-#include <iostream>
-#include <cstdio>
-using namespace std;
-
-const long long MAX = 93;
-
-long long f[MAX] = {0};
-
-long long fib(long long n)
-{
-
-    if (n == 0)
-        return 0;
-    if (n == 1 || n == 2)
-        return (f[n] = 1);
-
-    if (f[n])
-        return f[n];
-
-    long long k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
-
-    f[n] = (n % 2 != 0) ? (fib(k) * fib(k) + fib(k - 1) * fib(k - 1))
-                        : (2 * fib(k - 1) + fib(k)) * fib(k);
-    return f[n];
-}
-
-int main()
-{
-    //Main Function
-    for (long long i = 1; i < 93; i++)
-    {
-        cout << i << " th fibonacci number is " << fib(i) << "\n";
-    }
-    return 0;
-}
diff --git a/others/fibonacci_fast.cpp b/others/fibonacci_fast.cpp
new file mode 100644
index 000000000..dd3481422
--- /dev/null
+++ b/others/fibonacci_fast.cpp
@@ -0,0 +1,37 @@
+// An efficient way to calculate nth fibonacci number faster and simpler than
+// O(nlogn) method of matrix exponentiation This works by using both recursion
+// and dynamic programming. as 93rd fibonacci exceeds 19 digits, which cannot be
+// stored in a single long long variable, we can only use it till 92nd fibonacci
+// we can use it for 10000th fibonacci etc, if we implement bigintegers.
+// This algorithm works with the fact that nth fibonacci can easily found if we
+// have already found n/2th or (n+1)/2th fibonacci It is a property of fibonacci
+// similar to matrix exponentiation.
+
+#include <cstdio>
+#include <iostream>
+using namespace std;
+
+const long long MAX = 93;
+
+long long f[MAX] = {0};
+
+long long fib(long long n) {
+    if (n == 0) return 0;
+    if (n == 1 || n == 2) return (f[n] = 1);
+
+    if (f[n]) return f[n];
+
+    long long k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
+
+    f[n] = (n % 2 != 0) ? (fib(k) * fib(k) + fib(k - 1) * fib(k - 1))
+                        : (2 * fib(k - 1) + fib(k)) * fib(k);
+    return f[n];
+}
+
+int main() {
+    // Main Function
+    for (long long i = 1; i < 93; i++) {
+        cout << i << " th fibonacci number is " << fib(i) << "\n";
+    }
+    return 0;
+}
diff --git a/others/matrix_exponentiation.cpp b/others/matrix_exponentiation.cpp
index 25c411dda..f9b4997e9 100644
--- a/others/matrix_exponentiation.cpp
+++ b/others/matrix_exponentiation.cpp
@@ -19,6 +19,8 @@ The first element of this matrix is the required result.
 */
 
 #include <iostream>
+#include <vector>
+
 using std::cin;
 using std::cout;
 using std::vector;
@@ -46,8 +48,7 @@ vector<vector<ll>> multiply(vector<vector<ll>> A, vector<vector<ll>> B) {
 
 // computing power of a matrix
 vector<vector<ll>> power(vector<vector<ll>> A, ll p) {
-    if (p == 1)
-        return A;
+    if (p == 1) return A;
     if (p % 2 == 1) {
         return multiply(A, power(A, p - 1));
     } else {
@@ -58,14 +59,11 @@ vector<vector<ll>> power(vector<vector<ll>> A, ll p) {
 
 // main function
 ll ans(ll n) {
-    if (n == 0)
-        return 0;
-    if (n <= k)
-        return b[n - 1];
+    if (n == 0) return 0;
+    if (n <= k) return b[n - 1];
     // F1
     vector<ll> F1(k + 1);
-    for (ll i = 1; i <= k; i++)
-        F1[i] = b[i - 1];
+    for (ll i = 1; i <= k; i++) F1[i] = b[i - 1];
 
     // Transpose matrix
     vector<vector<ll>> T(k + 1, vector<ll>(k + 1));
diff --git a/others/Paranthesis Matching.cpp b/others/paranthesis_matching.cpp
similarity index 100%
rename from others/Paranthesis Matching.cpp
rename to others/paranthesis_matching.cpp
diff --git a/others/pascal_triangle.cpp b/others/pascal_triangle.cpp
index 101100018..063a6666a 100644
--- a/others/pascal_triangle.cpp
+++ b/others/pascal_triangle.cpp
@@ -1,63 +1,53 @@
-#include<iostream>
+#include <cstring>
+#include <iostream>
 
-using namespace std;
-
-void show_pascal(int **arr, int n)
-{
-	//pint Pascal's Triangle
-	for (int i = 0; i < n; ++i)
-	{
-		for (int j = 0; j < n + i; ++j)
-		{
-			if (arr[i][j] == 0)
-				cout << " ";
-			else
-				cout << arr[i][j];
-		}
-		cout << endl;
-	}
+void show_pascal(int **arr, int n) {
+    // pint Pascal's Triangle
+    for (int i = 0; i < n; ++i) {
+        for (int j = 0; j < n + i; ++j) {
+            if (arr[i][j] == 0)
+                std::cout << " ";
+            else
+                std::cout << arr[i][j];
+        }
+        std::cout << std::endl;
+    }
 }
 
-int **pascal_triangle(int **arr, int n)
-{
-	for (int i = 0; i < n; ++i)
-	{
-		for (int j = n - i - 1; j < n + i; ++j)
-		{
-			if (j == n - i - 1 || j == n + i - 1)
-				arr[i][j] = 1;				//The edge of the Pascal triangle goes in 1
-			else
-				arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j + 1];
-		}
-	}
+int **pascal_triangle(int **arr, int n) {
+    for (int i = 0; i < n; ++i) {
+        for (int j = n - i - 1; j < n + i; ++j) {
+            if (j == n - i - 1 || j == n + i - 1)
+                arr[i][j] = 1;  // The edge of the Pascal triangle goes in 1
+            else
+                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j + 1];
+        }
+    }
 
-	return arr;
+    return arr;
 }
 
-int main()
-{
-	int n = 0;
+int main() {
+    int n = 0;
 
-	cout << "Set Pascal's Triangle Height" << endl;
-	cin >> n;
-	
-	//memory allocation (Assign two-dimensional array to store Pascal triangle)
-	int **arr = new int*[n];
-	for (int i = 0; i < n; ++i)
-	{
-		arr[i] = new int[2 * n - 1];
-		memset(arr[i], 0, sizeof(int)*(2 * n - 1));
-	}
-	
-	pascal_triangle(arr, n);
-	show_pascal(arr, n);
+    std::cout << "Set Pascal's Triangle Height" << std::endl;
+    std::cin >> n;
 
-	//deallocation
-	for (int i = 0; i < n; ++i)
-	{
-		delete[] arr[i];
-	}
-	delete[] arr;
+    // memory allocation (Assign two-dimensional array to store Pascal triangle)
+    int **arr = new int *[n];
+    for (int i = 0; i < n; ++i) {
+        arr[i] = new int[2 * n - 1];
+        memset(arr[i], 0, sizeof(int) * (2 * n - 1));
+    }
 
-	return 0;
+    pascal_triangle(arr, n);
+    show_pascal(arr, n);
+
+    // deallocation
+    for (int i = 0; i < n; ++i) {
+        delete[] arr[i];
+    }
+    delete[] arr;
+
+    return 0;
 }
diff --git a/others/Primality Test.cpp b/others/primality_test.cpp
similarity index 100%
rename from others/Primality Test.cpp
rename to others/primality_test.cpp
diff --git a/others/Sparse matrix.cpp b/others/sparse_matrix.cpp
similarity index 100%
rename from others/Sparse matrix.cpp
rename to others/sparse_matrix.cpp
diff --git a/others/String Fibonacci.cpp b/others/string_fibonacci.cpp
similarity index 100%
rename from others/String Fibonacci.cpp
rename to others/string_fibonacci.cpp
diff --git a/others/Tower of Hanoi.cpp b/others/tower_of_hanoi.cpp
similarity index 100%
rename from others/Tower of Hanoi.cpp
rename to others/tower_of_hanoi.cpp
diff --git a/sorting/shell_sort2.cpp b/sorting/shell_sort2.cpp
new file mode 100644
index 000000000..1268c7a50
--- /dev/null
+++ b/sorting/shell_sort2.cpp
@@ -0,0 +1,105 @@
+#include <array>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+
+// for std::swap
+#include <utility>
+
+template <class T> void show_data(T *arr, size_t LEN) {
+  size_t i;
+
+  for (i = 0; i < LEN; i++)
+    std::cout << arr[i] << ", ";
+  std::cout << std::endl;
+}
+
+template <class T, size_t N> void show_data(T (&arr)[N]) { show_data(arr, N); }
+
+/**
+ * Optimized algorithm - takes half the time by utilizing
+ * Mar
+ **/
+template <class T> void shell_sort(T *arr, size_t LEN) {
+  const unsigned int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
+  const unsigned int gap_len = 8;
+  size_t i, j, g;
+
+  for (g = 0; g < gap_len; g++) {
+    unsigned int gap = gaps[g];
+    for (i = gap; i < LEN; i++) {
+      T tmp = arr[i];
+
+      for (j = i; j >= gap && (arr[j - gap] - tmp) > 0; j -= gap)
+        arr[j] = arr[j - gap];
+
+      arr[j] = tmp;
+    }
+  }
+}
+
+template <class T, size_t N> void shell_sort(T (&arr)[N]) {
+  shell_sort(arr, N);
+}
+
+/**
+ * function to compare sorting using cstdlib's qsort
+ **/
+int compare(const void *a, const void *b) {
+  int arg1 = *static_cast<const int *>(a);
+  int arg2 = *static_cast<const int *>(b);
+
+  if (arg1 < arg2)
+    return -1;
+  if (arg1 > arg2)
+    return 1;
+  return 0;
+
+  //  return (arg1 > arg2) - (arg1 < arg2); // possible shortcut
+  //  return arg1 - arg2; // erroneous shortcut (fails if INT_MIN is present)
+}
+
+int main(int argc, char *argv[]) {
+  int i, NUM_DATA;
+
+  if (argc == 2)
+    NUM_DATA = atoi(argv[1]);
+  else
+    NUM_DATA = 200;
+
+  // int array = new int[NUM_DATA];
+  int *data = new int[NUM_DATA];
+  int *data2 = new int[NUM_DATA];
+  // int array2 = new int[NUM_DATA];
+  int range = 1800;
+
+  std::srand(time(NULL));
+  for (i = 0; i < NUM_DATA; i++)
+    data[i] = data2[i] = (std::rand() % range) - (range >> 1);
+
+  std::cout << "Unsorted original data: " << std::endl;
+  show_data(data, NUM_DATA);
+  std::clock_t start = std::clock();
+  shell_sort(data, NUM_DATA);
+  std::clock_t end = std::clock();
+
+  std::cout << std::endl
+            << "Data Sorted using custom implementation: " << std::endl;
+  show_data(data, NUM_DATA);
+
+  double elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
+  std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
+
+  start = std::clock();
+  qsort(data2, NUM_DATA, sizeof(data2[0]), compare);
+  end = std::clock();
+  std::cout << "Data Sorted using cstdlib qsort: " << std::endl;
+  show_data(data2, NUM_DATA);
+
+  elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
+  std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
+
+  free(data);
+  free(data2);
+  return 0;
+}

From 15d481f8ca7e7a33b2d567108ea58252ec2318fe Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 03:13:48 +0000
Subject: [PATCH 034/290] updating DIRECTORY.md

---
 DIRECTORY.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 17cd5f5c6..644c57056 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -133,27 +133,26 @@
 
 ## Others
   * [Buzz Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Buzz_number.cpp)
-  * [Decimal To Binary](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Decimal%20To%20Binary.cpp)
-  * [Decimal To Hexadecimal ](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Decimal%20To%20Hexadecimal%20.cpp)
-  * [Decimal To Roman Numeral](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Decimal%20to%20Roman%20Numeral.cpp)
+  * [Decimal To Binary](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_binary.cpp)
+  * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_hexadecimal.cpp)
+  * [Decimal To Roman Numeral](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_roman_numeral.cpp)
   * [Fast Interger Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_interger_input.cpp)
-  * [Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci.cpp)
+  * [Fibonacci Fast](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_fast.cpp)
   * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/GCD_of_n_numbers.cpp)
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
   * [Measure Time Elapsed](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/measure_time_elapsed.cpp)
   * [Palindromeofnumber](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Palindromeofnumber.cpp)
-  * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Paranthesis%20Matching.cpp)
+  * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)
   * [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp)
-  * [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Primality%20Test.cpp)
+  * [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/primality_test.cpp)
   * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sieve_of_Eratosthenes.cpp)
   * [Smallest-Circle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/smallest-circle.cpp)
-  * [Sparse Matrix](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Sparse%20matrix.cpp)
+  * [Sparse Matrix](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sparse_matrix.cpp)
   * [Spiral Print](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/spiral_print.cpp)
   * [Stairs Pattern](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/stairs_pattern.cpp)
-  * [Strassen Matrix Multiplication](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Strassen%20Matrix%20Multiplication.cpp)
-  * [String Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/String%20Fibonacci.cpp)
-  * [Tower Of Hanoi](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Tower%20of%20Hanoi.cpp)
+  * [String Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/string_fibonacci.cpp)
+  * [Tower Of Hanoi](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/tower_of_hanoi.cpp)
   * [Vector Important Functions](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/vector_important_functions.cpp)
 
 ## Probability
@@ -200,6 +199,7 @@
   * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Radix%20Sort.cpp)
   * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Selection%20Sort.cpp)
   * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Shell%20Sort.cpp)
+  * [Shell Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort2.cpp)
   * [Slow Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Slow%20Sort.cpp)
   * [Swap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/swap_sort.cpp)
   * [Tim Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Tim%20Sort.cpp)

From 82dab7515cfc8a0ce11843ecb5bebcec64788c7c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 23:22:26 -0400
Subject: [PATCH 035/290] filenames and namespace fixes

---
 .../{Secant_method.CPP => secant_method.cpp}      |  0
 ...oximation.CPP => successive_approximation.cpp} |  0
 math/prime_factorization.cpp                      | 15 +++++++--------
 others/GCD_of_n_numbers.cpp                       |  3 ++-
 others/fibonacci_fast.cpp                         |  3 +--
 5 files changed, 10 insertions(+), 11 deletions(-)
 rename computer_oriented_statistical_methods/{Secant_method.CPP => secant_method.cpp} (100%)
 rename computer_oriented_statistical_methods/{successive_approximation.CPP => successive_approximation.cpp} (100%)

diff --git a/computer_oriented_statistical_methods/Secant_method.CPP b/computer_oriented_statistical_methods/secant_method.cpp
similarity index 100%
rename from computer_oriented_statistical_methods/Secant_method.CPP
rename to computer_oriented_statistical_methods/secant_method.cpp
diff --git a/computer_oriented_statistical_methods/successive_approximation.CPP b/computer_oriented_statistical_methods/successive_approximation.cpp
similarity index 100%
rename from computer_oriented_statistical_methods/successive_approximation.CPP
rename to computer_oriented_statistical_methods/successive_approximation.cpp
diff --git a/math/prime_factorization.cpp b/math/prime_factorization.cpp
index bd1b99d97..c018de666 100644
--- a/math/prime_factorization.cpp
+++ b/math/prime_factorization.cpp
@@ -2,13 +2,12 @@
 #include <cstring>
 #include <iostream>
 #include <vector>
-using namespace std;
 
 // Declaring variables for maintaing prime numbers and to check whether a number
 // is prime or not
 bool isprime[1000006];
-vector<int> prime_numbers;
-vector<pair<int, int>> factors;
+std::vector<int> prime_numbers;
+std::vector<std::pair<int, int>> factors;
 
 // Calculating prime number upto a given range
 void SieveOfEratosthenes(int N) {
@@ -43,7 +42,7 @@ void prime_factorization(int num) {
             number = number / prime_numbers[i];
         }
 
-        if (count) factors.push_back(make_pair(prime_numbers[i], count));
+        if (count) factors.push_back(std::make_pair(prime_numbers[i], count));
     }
 }
 
@@ -52,9 +51,9 @@ void prime_factorization(int num) {
 */
 int main() {
     int num;
-    cout << "\t\tComputes the prime factorization\n\n";
-    cout << "Type in a number: ";
-    cin >> num;
+    std::cout << "\t\tComputes the prime factorization\n\n";
+    std::cout << "Type in a number: ";
+    std::cin >> num;
 
     SieveOfEratosthenes(num);
 
@@ -62,7 +61,7 @@ int main() {
 
     // Prime factors with their powers in the given number in new line
     for (auto it : factors) {
-        cout << it.first << " " << it.second << endl;
+        std::cout << it.first << " " << it.second << std::endl;
     }
 
     return 0;
diff --git a/others/GCD_of_n_numbers.cpp b/others/GCD_of_n_numbers.cpp
index b592e5931..37e82173a 100644
--- a/others/GCD_of_n_numbers.cpp
+++ b/others/GCD_of_n_numbers.cpp
@@ -5,7 +5,7 @@ int main() {
     int n;
     std::cout << "Enter value of n:" << std::endl;
     std::cin >> n;
-    int a[n];
+    int *a = new int[n];
     int i, j, gcd;
     std::cout << "Enter the n numbers:" << std::endl;
     for (i = 0; i < n; i++) std::cin >> a[i];
@@ -18,5 +18,6 @@ int main() {
             gcd = a[j] % gcd;  // calculating GCD by division method
     }
     std::cout << "GCD of entered n numbers:" << gcd;
+    delete[] a;
     return 0;
 }
diff --git a/others/fibonacci_fast.cpp b/others/fibonacci_fast.cpp
index dd3481422..381a82d7c 100644
--- a/others/fibonacci_fast.cpp
+++ b/others/fibonacci_fast.cpp
@@ -9,7 +9,6 @@
 
 #include <cstdio>
 #include <iostream>
-using namespace std;
 
 const long long MAX = 93;
 
@@ -31,7 +30,7 @@ long long fib(long long n) {
 int main() {
     // Main Function
     for (long long i = 1; i < 93; i++) {
-        cout << i << " th fibonacci number is " << fib(i) << "\n";
+        std::cout << i << " th fibonacci number is " << fib(i) << "\n";
     }
     return 0;
 }

From 4c7685fdf6f14a6ae9924757f5f9bf05281812d8 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 03:22:58 +0000
Subject: [PATCH 036/290] updating DIRECTORY.md

---
 DIRECTORY.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 644c57056..f21574454 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -15,8 +15,8 @@
   * [Gaussian Elimination](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Gaussian_elimination.cpp)
   * [Newton Raphson Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/newton_raphson_method.cpp)
   * [Ordinary Least Squares Regressor](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp)
-  * [Secant Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Secant_method.CPP)
-  * [Successive Approximation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/successive_approximation.CPP)
+  * [Secant Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/secant_method.cpp)
+  * [Successive Approximation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/successive_approximation.cpp)
 
 ## Data Structure
   * [Avltree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/AVLtree.cpp)

From c93f3ef35eb05cef312be1cab83bafda83f6011b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 23:25:44 -0400
Subject: [PATCH 037/290] fix inttypes

---
 others/fibonacci_fast.cpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/others/fibonacci_fast.cpp b/others/fibonacci_fast.cpp
index 381a82d7c..a0b83b640 100644
--- a/others/fibonacci_fast.cpp
+++ b/others/fibonacci_fast.cpp
@@ -7,20 +7,21 @@
 // have already found n/2th or (n+1)/2th fibonacci It is a property of fibonacci
 // similar to matrix exponentiation.
 
+#include <cinttypes>
 #include <cstdio>
 #include <iostream>
 
-const long long MAX = 93;
+const uint64_t MAX = 93;
 
-long long f[MAX] = {0};
+uint64_t f[MAX] = {0};
 
-long long fib(long long n) {
+uint64_t fib(uint64_t n) {
     if (n == 0) return 0;
     if (n == 1 || n == 2) return (f[n] = 1);
 
     if (f[n]) return f[n];
 
-    long long k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
+    uint64_t k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
 
     f[n] = (n % 2 != 0) ? (fib(k) * fib(k) + fib(k - 1) * fib(k - 1))
                         : (2 * fib(k - 1) + fib(k)) * fib(k);
@@ -29,7 +30,7 @@ long long fib(long long n) {
 
 int main() {
     // Main Function
-    for (long long i = 1; i < 93; i++) {
+    for (uint64_t i = 1; i < 93; i++) {
         std::cout << i << " th fibonacci number is " << fib(i) << "\n";
     }
     return 0;

From b9bb6caa73083da8fc0d74d366dd9262da081c3d Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 23:32:31 -0400
Subject: [PATCH 038/290] made functions static to files *BUG* in CPP lint
 github action

---
 .../Gaussian_elimination.cpp                  | 52 ++++++++-----------
 ...ection_method.CPP => bisection_method.cpp} |  2 +-
 .../false-position.cpp                        | 21 ++++----
 .../newton_raphson_method.cpp                 |  5 +-
 .../secant_method.cpp                         |  2 +-
 .../successive_approximation.cpp              |  5 +-
 6 files changed, 40 insertions(+), 47 deletions(-)
 rename computer_oriented_statistical_methods/{Bisection_method.CPP => bisection_method.cpp} (96%)

diff --git a/computer_oriented_statistical_methods/Gaussian_elimination.cpp b/computer_oriented_statistical_methods/Gaussian_elimination.cpp
index 58e634505..ecfbfacc9 100644
--- a/computer_oriented_statistical_methods/Gaussian_elimination.cpp
+++ b/computer_oriented_statistical_methods/Gaussian_elimination.cpp
@@ -1,29 +1,23 @@
 #include <iostream>
-using namespace std;
 
-int main()
-{
+int main() {
     int mat_size, i, j, step;
 
-    cout << "Matrix size: ";
-    cin >> mat_size;
+    std::cout << "Matrix size: ";
+    std::cin >> mat_size;
 
     double mat[mat_size + 1][mat_size + 1], x[mat_size][mat_size + 1];
 
-    cout << endl
-         << "Enter value of the matrix: " << endl;
-    for (i = 0; i < mat_size; i++)
-    {
-        for (j = 0; j <= mat_size; j++)
-        {
-            cin >> mat[i][j]; //Enter (mat_size*mat_size) value of the matrix.
+    std::cout << std::endl << "Enter value of the matrix: " << std::endl;
+    for (i = 0; i < mat_size; i++) {
+        for (j = 0; j <= mat_size; j++) {
+            std::cin >>
+                mat[i][j];  // Enter (mat_size*mat_size) value of the matrix.
         }
     }
 
-    for (step = 0; step < mat_size - 1; step++)
-    {
-        for (i = step; i < mat_size - 1; i++)
-        {
+    for (step = 0; step < mat_size - 1; step++) {
+        for (i = step; i < mat_size - 1; i++) {
             double a = (mat[i + 1][step] / mat[step][step]);
 
             for (j = step; j <= mat_size; j++)
@@ -31,24 +25,20 @@ int main()
         }
     }
 
-    cout << endl
-         << "Matrix using Gaussian Elimination method: " << endl;
-    for (i = 0; i < mat_size; i++)
-    {
-        for (j = 0; j <= mat_size; j++)
-        {
+    std::cout << std::endl
+              << "Matrix using Gaussian Elimination method: " << std::endl;
+    for (i = 0; i < mat_size; i++) {
+        for (j = 0; j <= mat_size; j++) {
             x[i][j] = mat[i][j];
-            cout << mat[i][j] << " ";
+            std::cout << mat[i][j] << " ";
         }
-        cout << endl;
+        std::cout << std::endl;
     }
-    cout << endl
-         << "Value of the Gaussian Elimination method: " << endl;
-    for (i = mat_size - 1; i >= 0; i--)
-    {
+    std::cout << std::endl
+              << "Value of the Gaussian Elimination method: " << std::endl;
+    for (i = mat_size - 1; i >= 0; i--) {
         double sum = 0;
-        for (j = mat_size - 1; j > i; j--)
-        {
+        for (j = mat_size - 1; j > i; j--) {
             x[i][j] = x[j][j] * x[i][j];
             sum = x[i][j] + sum;
         }
@@ -57,7 +47,7 @@ int main()
         else
             x[i][i] = (x[i][mat_size] - sum) / (x[i][i]);
 
-        cout << "x" << i << "= " << x[i][i] << endl;
+        std::cout << "x" << i << "= " << x[i][i] << std::endl;
     }
     return 0;
 }
diff --git a/computer_oriented_statistical_methods/Bisection_method.CPP b/computer_oriented_statistical_methods/bisection_method.cpp
similarity index 96%
rename from computer_oriented_statistical_methods/Bisection_method.CPP
rename to computer_oriented_statistical_methods/bisection_method.cpp
index 266083de1..089828c9a 100644
--- a/computer_oriented_statistical_methods/Bisection_method.CPP
+++ b/computer_oriented_statistical_methods/bisection_method.cpp
@@ -1,7 +1,7 @@
 #include <cmath>
 #include <iostream>
 
-float eq(float i) {
+static float eq(float i) {
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
diff --git a/computer_oriented_statistical_methods/false-position.cpp b/computer_oriented_statistical_methods/false-position.cpp
index 5e15e92cc..c5a314508 100644
--- a/computer_oriented_statistical_methods/false-position.cpp
+++ b/computer_oriented_statistical_methods/false-position.cpp
@@ -1,9 +1,11 @@
-#include<stdlib.h>
-#include <math.h>
+#include <cmath>
+#include <cstdlib>
 #include <iostream>
-float eq(float i) {
+
+static float eq(float i) {
     return (pow(i, 3) - (4 * i) - 9);  // origial equation
 }
+
 int main() {
     float a, b, z, c, m, n;
     system("clear");
@@ -12,12 +14,13 @@ int main() {
         if (z >= 0) {
             b = i;
             a = --i;
-            goto START;
-            }
+            break;
         }
-    START:
+    }
+
     std::cout << "\nFirst initial: " << a;
     std::cout << "\nSecond initial: " << b;
+
     for (int i = 0; i < 100; i++) {
         float h, d;
         m = eq(a);
@@ -26,10 +29,10 @@ int main() {
         a = c;
         z = eq(c);
         if (z > 0 && z < 0.09) {  // stoping criteria
-            goto END;
+            break;
         }
     }
-    END:
+
     std::cout << "\n\nRoot: " << c;
-    system("pause");
+    return 0;
 }
diff --git a/computer_oriented_statistical_methods/newton_raphson_method.cpp b/computer_oriented_statistical_methods/newton_raphson_method.cpp
index a2a57768e..47d276490 100644
--- a/computer_oriented_statistical_methods/newton_raphson_method.cpp
+++ b/computer_oriented_statistical_methods/newton_raphson_method.cpp
@@ -1,10 +1,11 @@
 #include <cmath>
 #include <iostream>
 
-float eq(float i) {
+static float eq(float i) {
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
-float eq_der(float i) {
+
+static float eq_der(float i) {
     return ((3 * std::pow(i, 2)) - 4);  // derivative of equation
 }
 
diff --git a/computer_oriented_statistical_methods/secant_method.cpp b/computer_oriented_statistical_methods/secant_method.cpp
index bd805ed36..c353ef850 100644
--- a/computer_oriented_statistical_methods/secant_method.cpp
+++ b/computer_oriented_statistical_methods/secant_method.cpp
@@ -1,7 +1,7 @@
 #include <cmath>
 #include <iostream>
 
-float eq(float i) {
+static float eq(float i) {
     return (pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
diff --git a/computer_oriented_statistical_methods/successive_approximation.cpp b/computer_oriented_statistical_methods/successive_approximation.cpp
index 85c42c9fb..efbcc3bbf 100644
--- a/computer_oriented_statistical_methods/successive_approximation.cpp
+++ b/computer_oriented_statistical_methods/successive_approximation.cpp
@@ -1,9 +1,8 @@
-
 #include <cmath>
 #include <iostream>
 
-float eq(float y) { return ((3 * y) - (cos(y)) - 2); }
-float eqd(float y) { return ((0.5) * ((cos(y)) + 2)); }
+static float eq(float y) { return ((3 * y) - (cos(y)) - 2); }
+static float eqd(float y) { return ((0.5) * ((cos(y)) + 2)); }
 
 int main() {
     float y, x1, x2, x3, sum, s, a, f1, f2, gd;

From 2e2f9c209ca0ea04e59117859f2f0f08f638fbf4 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 03:32:54 +0000
Subject: [PATCH 039/290] updating DIRECTORY.md

---
 DIRECTORY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index f21574454..26210d6d4 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -10,7 +10,7 @@
   * [Sudoku Solve](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/backtracking/sudoku_solve.cpp)
 
 ## Computer Oriented Statistical Methods
-  * [Bisection Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Bisection_method.CPP)
+  * [Bisection Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/bisection_method.cpp)
   * [False-Position](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/false-position.cpp)
   * [Gaussian Elimination](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Gaussian_elimination.cpp)
   * [Newton Raphson Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/newton_raphson_method.cpp)

From 9c0025aa3d1c1a01ef78b0ceeab775a796d66abd Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Mon, 25 May 2020 23:42:37 -0400
Subject: [PATCH 040/290] added cmake to math, others and compu_stats

---
 CMakeLists.txt                                | 32 ++++++-------------
 .../CMakeLists.txt                            | 18 +++++++++++
 math/CMakeLists.txt                           | 18 +++++++++++
 others/CMakeLists.txt                         | 18 +++++++++++
 4 files changed, 64 insertions(+), 22 deletions(-)
 create mode 100644 computer_oriented_statistical_methods/CMakeLists.txt
 create mode 100644 math/CMakeLists.txt
 create mode 100644 others/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f98109382..b9c7831c8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,10 +1,13 @@
 cmake_minimum_required(VERSION 3.3)
-project(Algorithms_in_C
-    LANGUAGES C CXX
+project(Algorithms_in_C++
+    LANGUAGES CXX
     VERSION 1.0.0
     DESCRIPTION "Set of algorithms implemented in C."
 )
 
+# set(CMAKE_CXX_CPPLINT "~/anaconda3/bin/cpplint --filter=-legal/copyright --std=c++11")
+# find_program(CLANG_FORMAT "clang-format")
+
 option(USE_OPENMP "flag to use OpenMP for multithreading" ON)
 
 cmake_policy(SET CMP0054 NEW)
@@ -34,32 +37,17 @@ if(DOXYGEN_FOUND)
     )
 endif()
 
-function(function_timer)
-    set(CMAKE_BUILD_TYPE "Release")         # This is local to function
-    add_subdirectory(function_timer EXCLUDE_FROM_ALL)
-endfunction()
-
-function_timer()
-
-include_directories(function_timer/include)
-# link_libraries(function_timer)
-# include_directories(${CMAKE_BINARY_DIR}/include)
-# link_directories(${CMAKE_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE})
-
-set(CMAKE_C_STANDARD 11)
-set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(MSVC)
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
     add_compile_options(/Za)
 endif(MSVC)
 
-add_subdirectory(conversions)
-add_subdirectory(misc)
-add_subdirectory(project_euler)
-add_subdirectory(sorting)
-add_subdirectory(searching)
-add_subdirectory(numerical_methods)
+add_subdirectory(math)
+add_subdirectory(others)
+add_subdirectory(computer_oriented_statistical_methods)
 
 if(USE_OPENMP)
     find_package(OpenMP)
diff --git a/computer_oriented_statistical_methods/CMakeLists.txt b/computer_oriented_statistical_methods/CMakeLists.txt
new file mode 100644
index 000000000..acff1ed1c
--- /dev/null
+++ b/computer_oriented_statistical_methods/CMakeLists.txt
@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/stats")
+
+endforeach( testsourcefile ${APP_SOURCES} )
diff --git a/math/CMakeLists.txt b/math/CMakeLists.txt
new file mode 100644
index 000000000..2b70b2d31
--- /dev/null
+++ b/math/CMakeLists.txt
@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/math")
+
+endforeach( testsourcefile ${APP_SOURCES} )
diff --git a/others/CMakeLists.txt b/others/CMakeLists.txt
new file mode 100644
index 000000000..f049b5f2d
--- /dev/null
+++ b/others/CMakeLists.txt
@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/others")
+
+endforeach( testsourcefile ${APP_SOURCES} )

From 565031ba73b6668a244ccdba78f56e197ae5eada Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 00:09:07 -0400
Subject: [PATCH 041/290] added documentation

---
 .../ordinary_least_squares_regressor.cpp      | 609 ++++++++++--------
 1 file changed, 329 insertions(+), 280 deletions(-)

diff --git a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
index f50ccf1b1..41acfa10a 100644
--- a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
+++ b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
@@ -1,349 +1,398 @@
 /**
+ * @file
+ *
  * Program that gets the number of data samples and number of features per
  * sample along with output per sample. It applies OLS regression to compute
  * the regression output for additional test data samples.
- **/
+ */
 #include <iomanip>
 #include <iostream>
 #include <vector>
 
+/**
+ * operator to print a matrix
+ */
 template <typename T>
 std::ostream &operator<<(std::ostream &out,
                          std::vector<std::vector<T>> const &v) {
-  const int width = 10;
-  const char separator = ' ';
+    const int width = 10;
+    const char separator = ' ';
 
-  for (size_t row = 0; row < v.size(); row++) {
-    for (size_t col = 0; col < v[row].size(); col++)
-      out << std::left << std::setw(width) << std::setfill(separator)
-          << v[row][col];
-    out << std::endl;
-  }
+    for (size_t row = 0; row < v.size(); row++) {
+        for (size_t col = 0; col < v[row].size(); col++)
+            out << std::left << std::setw(width) << std::setfill(separator)
+                << v[row][col];
+        out << std::endl;
+    }
 
-  return out;
-}
-
-template <typename T>
-std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
-  const int width = 15;
-  const char separator = ' ';
-
-  for (size_t row = 0; row < v.size(); row++)
-    out << std::left << std::setw(width) << std::setfill(separator) << v[row];
-
-  return out;
-}
-
-template <typename T>
-inline bool is_square(std::vector<std::vector<T>> const &A) {
-  // Assuming A is square matrix
-  size_t N = A.size();
-  for (size_t i = 0; i < N; i++)
-    if (A[i].size() != N)
-      return false;
-  return true;
+    return out;
 }
 
 /**
- * matrix multiplication
+ * operator to print a vector
+ */
+template <typename T>
+std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
+    const int width = 15;
+    const char separator = ' ';
+
+    for (size_t row = 0; row < v.size(); row++)
+        out << std::left << std::setw(width) << std::setfill(separator)
+            << v[row];
+
+    return out;
+}
+
+/**
+ * function to check if given matrix is a square matrix
+ * \returns 1 if true, 0 if false
+ */
+template <typename T>
+inline bool is_square(std::vector<std::vector<T>> const &A) {
+    // Assuming A is square matrix
+    size_t N = A.size();
+    for (size_t i = 0; i < N; i++)
+        if (A[i].size() != N) return false;
+    return true;
+}
+
+/**
+ * Matrix multiplication such that if A is size (mxn) and
+ * B is of size (pxq) then the multiplication is defined
+ * only when n = p and the resultant matrix is of size (mxq)
+ *
+ * \returns resultant matrix
  **/
 template <typename T>
 std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
                                       std::vector<std::vector<T>> const &B) {
-  // Number of rows in A
-  size_t N_A = A.size();
-  // Number of columns in B
-  size_t N_B = B[0].size();
+    // Number of rows in A
+    size_t N_A = A.size();
+    // Number of columns in B
+    size_t N_B = B[0].size();
 
-  std::vector<std::vector<T>> result(N_A);
+    std::vector<std::vector<T>> result(N_A);
 
-  if (A[0].size() != B.size()) {
-    std::cerr << "Number of columns in A != Number of rows in B ("
-              << A[0].size() << ", " << B.size() << ")" << std::endl;
-    return result;
-  }
-
-  for (size_t row = 0; row < N_A; row++) {
-    std::vector<T> v(N_B);
-    for (size_t col = 0; col < N_B; col++) {
-      v[col] = static_cast<T>(0);
-      for (size_t j = 0; j < B.size(); j++)
-        v[col] += A[row][j] * B[j][col];
+    if (A[0].size() != B.size()) {
+        std::cerr << "Number of columns in A != Number of rows in B ("
+                  << A[0].size() << ", " << B.size() << ")" << std::endl;
+        return result;
     }
-    result[row] = v;
-  }
 
-  return result;
-}
+    for (size_t row = 0; row < N_A; row++) {
+        std::vector<T> v(N_B);
+        for (size_t col = 0; col < N_B; col++) {
+            v[col] = static_cast<T>(0);
+            for (size_t j = 0; j < B.size(); j++)
+                v[col] += A[row][j] * B[j][col];
+        }
+        result[row] = v;
+    }
 
-template <typename T>
-std::vector<T> operator*(std::vector<std::vector<T>> const &A,
-                         std::vector<T> const &B) {
-  // Number of rows in A
-  size_t N_A = A.size();
-
-  std::vector<T> result(N_A);
-
-  if (A[0].size() != B.size()) {
-    std::cerr << "Number of columns in A != Number of rows in B ("
-              << A[0].size() << ", " << B.size() << ")" << std::endl;
     return result;
-  }
-
-  for (size_t row = 0; row < N_A; row++) {
-    result[row] = static_cast<T>(0);
-    for (size_t j = 0; j < B.size(); j++)
-      result[row] += A[row][j] * B[j];
-  }
-
-  return result;
-}
-
-template <typename T>
-std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
-  // Number of rows in A
-  size_t N_A = A.size();
-
-  std::vector<float> result(N_A);
-
-  for (size_t row = 0; row < N_A; row++) {
-    result[row] += A[row] * static_cast<float>(scalar);
-  }
-
-  return result;
-}
-
-template <typename T>
-std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
-  // Number of rows in A
-  size_t N_A = A.size();
-
-  std::vector<float> result(N_A);
-
-  for (size_t row = 0; row < N_A; row++)
-    result[row] = A[row] * static_cast<float>(scalar);
-
-  return result;
-}
-
-template <typename T>
-std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
-  return (1.f / scalar) * A;
-}
-
-template <typename T>
-std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
-  // Number of rows in A
-  size_t N = A.size();
-
-  std::vector<T> result(N);
-
-  if (B.size() != N) {
-    std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
-    return A;
-  }
-
-  for (size_t row = 0; row < N; row++)
-    result[row] = A[row] - B[row];
-
-  return result;
-}
-
-template <typename T>
-std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
-  // Number of rows in A
-  size_t N = A.size();
-
-  std::vector<T> result(N);
-
-  if (B.size() != N) {
-    std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
-    return A;
-  }
-
-  for (size_t row = 0; row < N; row++)
-    result[row] = A[row] + B[row];
-
-  return result;
 }
 
 /**
- * Get matrix inverse using Row-trasnformations
+ * multiplication of a matrix with a column vector
+ * \returns resultant vector
+ */
+template <typename T>
+std::vector<T> operator*(std::vector<std::vector<T>> const &A,
+                         std::vector<T> const &B) {
+    // Number of rows in A
+    size_t N_A = A.size();
+
+    std::vector<T> result(N_A);
+
+    if (A[0].size() != B.size()) {
+        std::cerr << "Number of columns in A != Number of rows in B ("
+                  << A[0].size() << ", " << B.size() << ")" << std::endl;
+        return result;
+    }
+
+    for (size_t row = 0; row < N_A; row++) {
+        result[row] = static_cast<T>(0);
+        for (size_t j = 0; j < B.size(); j++) result[row] += A[row][j] * B[j];
+    }
+
+    return result;
+}
+
+/**
+ * pre-multiplication of a vector by a scalar
+ * \returns resultant vector
+ */
+template <typename T>
+std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
+    // Number of rows in A
+    size_t N_A = A.size();
+
+    std::vector<float> result(N_A);
+
+    for (size_t row = 0; row < N_A; row++) {
+        result[row] += A[row] * static_cast<float>(scalar);
+    }
+
+    return result;
+}
+
+/**
+ * post-multiplication of a vector by a scalar
+ * \returns resultant vector
+ */
+template <typename T>
+std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
+    // Number of rows in A
+    size_t N_A = A.size();
+
+    std::vector<float> result(N_A);
+
+    for (size_t row = 0; row < N_A; row++)
+        result[row] = A[row] * static_cast<float>(scalar);
+
+    return result;
+}
+
+/**
+ * division of a vector by a scalar
+ * \returns resultant vector
+ */
+template <typename T>
+std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
+    return (1.f / scalar) * A;
+}
+
+/**
+ * subtraction of two vectors of identical lengths
+ * \returns resultant vector
+ */
+template <typename T>
+std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
+    // Number of rows in A
+    size_t N = A.size();
+
+    std::vector<T> result(N);
+
+    if (B.size() != N) {
+        std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
+        return A;
+    }
+
+    for (size_t row = 0; row < N; row++) result[row] = A[row] - B[row];
+
+    return result;
+}
+
+/**
+ * addition of two vectors of identical lengths
+ * \returns resultant vector
+ */
+template <typename T>
+std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
+    // Number of rows in A
+    size_t N = A.size();
+
+    std::vector<T> result(N);
+
+    if (B.size() != N) {
+        std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
+        return A;
+    }
+
+    for (size_t row = 0; row < N; row++) result[row] = A[row] + B[row];
+
+    return result;
+}
+
+/**
+ * Get matrix inverse using Row-trasnformations. Given matrix must
+ * be a square and non-singular.
+ * \returns inverse matrix
  **/
 template <typename T>
-std::vector<std::vector<float>>
-get_inverse(std::vector<std::vector<T>> const &A) {
-  // Assuming A is square matrix
-  size_t N = A.size();
+std::vector<std::vector<float>> get_inverse(
+    std::vector<std::vector<T>> const &A) {
+    // Assuming A is square matrix
+    size_t N = A.size();
 
-  std::vector<std::vector<float>> inverse(N);
-  for (size_t row = 0; row < N; row++) {
-    // preallocatae a resultant identity matrix
-    inverse[row] = std::vector<float>(N);
-    for (size_t col = 0; col < N; col++)
-      inverse[row][col] = (row == col) ? 1.f : 0.f;
-  }
+    std::vector<std::vector<float>> inverse(N);
+    for (size_t row = 0; row < N; row++) {
+        // preallocatae a resultant identity matrix
+        inverse[row] = std::vector<float>(N);
+        for (size_t col = 0; col < N; col++)
+            inverse[row][col] = (row == col) ? 1.f : 0.f;
+    }
+
+    if (!is_square(A)) {
+        std::cerr << "A must be a square matrix!" << std::endl;
+        return inverse;
+    }
+
+    // preallocatae a temporary matrix identical to A
+    std::vector<std::vector<float>> temp(N);
+    for (size_t row = 0; row < N; row++) {
+        std::vector<float> v(N);
+        for (size_t col = 0; col < N; col++)
+            v[col] = static_cast<float>(A[row][col]);
+        temp[row] = v;
+    }
+
+    // start transformations
+    for (size_t row = 0; row < N; row++) {
+        for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++) {
+            // this to ensure diagonal elements are not 0
+            temp[row] = temp[row] + temp[row2];
+            inverse[row] = inverse[row] + inverse[row2];
+        }
+
+        for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++) {
+            // this to further ensure diagonal elements are not 0
+            for (size_t row2 = 0; row2 < N; row2++) {
+                temp[row2][row] = temp[row2][row] + temp[row2][col2];
+                inverse[row2][row] = inverse[row2][row] + inverse[row2][col2];
+            }
+        }
+
+        if (temp[row][row] == 0) {
+            // Probably a low-rank matrix and hence singular
+            std::cerr << "Low-rank matrix, no inverse!" << std::endl;
+            return inverse;
+        }
+
+        // set diagonal to 1
+        float divisor = static_cast<float>(temp[row][row]);
+        temp[row] = temp[row] / divisor;
+        inverse[row] = inverse[row] / divisor;
+        // Row transformations
+        for (size_t row2 = 0; row2 < N; row2++) {
+            if (row2 == row) continue;
+            float factor = temp[row2][row];
+            temp[row2] = temp[row2] - factor * temp[row];
+            inverse[row2] = inverse[row2] - factor * inverse[row];
+        }
+    }
 
-  if (!is_square(A)) {
-    std::cerr << "A must be a square matrix!" << std::endl;
     return inverse;
-  }
-
-  // preallocatae a temporary matrix identical to A
-  std::vector<std::vector<float>> temp(N);
-  for (size_t row = 0; row < N; row++) {
-    std::vector<float> v(N);
-    for (size_t col = 0; col < N; col++)
-      v[col] = static_cast<float>(A[row][col]);
-    temp[row] = v;
-  }
-
-  // start transformations
-  for (size_t row = 0; row < N; row++) {
-    for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++) {
-      // this to ensure diagonal elements are not 0
-      temp[row] = temp[row] + temp[row2];
-      inverse[row] = inverse[row] + inverse[row2];
-    }
-
-    for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++) {
-      // this to further ensure diagonal elements are not 0
-      for (size_t row2 = 0; row2 < N; row2++) {
-        temp[row2][row] = temp[row2][row] + temp[row2][col2];
-        inverse[row2][row] = inverse[row2][row] + inverse[row2][col2];
-      }
-    }
-
-    if (temp[row][row] == 0) {
-      // Probably a low-rank matrix and hence singular
-      std::cerr << "Low-rank matrix, no inverse!" << std::endl;
-      return inverse;
-    }
-
-    // set diagonal to 1
-    float divisor = static_cast<float>(temp[row][row]);
-    temp[row] = temp[row] / divisor;
-    inverse[row] = inverse[row] / divisor;
-    // Row transformations
-    for (size_t row2 = 0; row2 < N; row2++) {
-      if (row2 == row)
-        continue;
-      float factor = temp[row2][row];
-      temp[row2] = temp[row2] - factor * temp[row];
-      inverse[row2] = inverse[row2] - factor * inverse[row];
-    }
-  }
-
-  return inverse;
 }
 
 /**
  * matrix transpose
+ * \returns resultant matrix
  **/
 template <typename T>
-std::vector<std::vector<T>>
-get_transpose(std::vector<std::vector<T>> const &A) {
-  std::vector<std::vector<T>> result(A[0].size());
+std::vector<std::vector<T>> get_transpose(
+    std::vector<std::vector<T>> const &A) {
+    std::vector<std::vector<T>> result(A[0].size());
 
-  for (size_t row = 0; row < A[0].size(); row++) {
-    std::vector<T> v(A.size());
-    for (size_t col = 0; col < A.size(); col++)
-      v[col] = A[col][row];
+    for (size_t row = 0; row < A[0].size(); row++) {
+        std::vector<T> v(A.size());
+        for (size_t col = 0; col < A.size(); col++) v[col] = A[col][row];
 
-    result[row] = v;
-  }
-  return result;
+        result[row] = v;
+    }
+    return result;
 }
 
+/**
+ * Perform Ordinary Least Squares curve fit.
+ * \param X feature matrix with rows representing sample vector of features
+ * \param Y known regression value for each sample
+ * \returns fitted regression model polynomial coefficients
+ */
 template <typename T>
 std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
                                      std::vector<T> const &Y) {
-  // NxF
-  std::vector<std::vector<T>> X2 = X;
-  for (size_t i = 0; i < X2.size(); i++)
-    // add Y-intercept -> Nx(F+1)
-    X2[i].push_back(1);
-  // (F+1)xN
-  std::vector<std::vector<T>> Xt = get_transpose(X2);
-  // (F+1)x(F+1)
-  std::vector<std::vector<T>> tmp = get_inverse(Xt * X2);
-  // (F+1)xN
-  std::vector<std::vector<float>> out = tmp * Xt;
-  // cout << endl
-  //      << "Projection matrix: " << X2 * out << endl;
+    // NxF
+    std::vector<std::vector<T>> X2 = X;
+    for (size_t i = 0; i < X2.size(); i++)
+        // add Y-intercept -> Nx(F+1)
+        X2[i].push_back(1);
+    // (F+1)xN
+    std::vector<std::vector<T>> Xt = get_transpose(X2);
+    // (F+1)x(F+1)
+    std::vector<std::vector<T>> tmp = get_inverse(Xt * X2);
+    // (F+1)xN
+    std::vector<std::vector<float>> out = tmp * Xt;
+    // cout << endl
+    //      << "Projection matrix: " << X2 * out << endl;
 
-  // Fx1,1    -> (F+1)^th element is the independent constant
-  return out * Y;
+    // Fx1,1    -> (F+1)^th element is the independent constant
+    return out * Y;
 }
 
 /**
  * Given data and OLS model coeffficients, predict
- * regression estimates
+ * regression estimates.
+ * \param X feature matrix with rows representing sample vector of features
+ * \param \f$\beta\f$ fitted regression model
+ * \return vector with regression values for each sample
  **/
 template <typename T>
 std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
-                                         std::vector<float> const &beta) {
-  std::vector<float> result(X.size());
+                                         std::vector<float> const &beta /**< */
+) {
+    std::vector<float> result(X.size());
 
-  for (size_t rows = 0; rows < X.size(); rows++) {
-    // -> start with constant term
-    result[rows] = beta[X[0].size()];
-    for (size_t cols = 0; cols < X[0].size(); cols++)
-      result[rows] += beta[cols] * X[rows][cols];
-  }
-  // Nx1
-  return result;
+    for (size_t rows = 0; rows < X.size(); rows++) {
+        // -> start with constant term
+        result[rows] = beta[X[0].size()];
+        for (size_t cols = 0; cols < X[0].size(); cols++)
+            result[rows] += beta[cols] * X[rows][cols];
+    }
+    // Nx1
+    return result;
 }
 
+/**
+ * main function
+ */
 int main() {
-  size_t N, F;
+    size_t N, F;
 
-  std::cout << "Enter number of features: ";
-  // number of features = columns
-  std::cin >> F;
-  std::cout << "Enter number of samples: ";
-  // number of samples = rows
-  std::cin >> N;
+    std::cout << "Enter number of features: ";
+    // number of features = columns
+    std::cin >> F;
+    std::cout << "Enter number of samples: ";
+    // number of samples = rows
+    std::cin >> N;
 
-  std::vector<std::vector<float>> data(N);
-  std::vector<float> Y(N);
+    std::vector<std::vector<float>> data(N);
+    std::vector<float> Y(N);
 
-  std::cout
-      << "Enter training data. Per sample, provide features ad one output."
-      << std::endl;
+    std::cout
+        << "Enter training data. Per sample, provide features ad one output."
+        << std::endl;
 
-  for (size_t rows = 0; rows < N; rows++) {
-    std::vector<float> v(F);
-    std::cout << "Sample# " << rows + 1 << ": ";
-    for (size_t cols = 0; cols < F; cols++)
-      // get the F features
-      std::cin >> v[cols];
-    data[rows] = v;
-    // get the corresponding output
-    std::cin >> Y[rows];
-  }
+    for (size_t rows = 0; rows < N; rows++) {
+        std::vector<float> v(F);
+        std::cout << "Sample# " << rows + 1 << ": ";
+        for (size_t cols = 0; cols < F; cols++)
+            // get the F features
+            std::cin >> v[cols];
+        data[rows] = v;
+        // get the corresponding output
+        std::cin >> Y[rows];
+    }
 
-  std::vector<float> beta = fit_OLS_regressor(data, Y);
-  std::cout << std::endl << std::endl << "beta:" << beta << std::endl;
+    std::vector<float> beta = fit_OLS_regressor(data, Y);
+    std::cout << std::endl << std::endl << "beta:" << beta << std::endl;
 
-  size_t T;
-  std::cout << "Enter number of test samples: ";
-  // number of test sample inputs
-  std::cin >> T;
-  std::vector<std::vector<float>> data2(T);
-  // vector<float> Y2(T);
+    size_t T;
+    std::cout << "Enter number of test samples: ";
+    // number of test sample inputs
+    std::cin >> T;
+    std::vector<std::vector<float>> data2(T);
+    // vector<float> Y2(T);
 
-  for (size_t rows = 0; rows < T; rows++) {
-    std::cout << "Sample# " << rows + 1 << ": ";
-    std::vector<float> v(F);
-    for (size_t cols = 0; cols < F; cols++)
-      std::cin >> v[cols];
-    data2[rows] = v;
-  }
+    for (size_t rows = 0; rows < T; rows++) {
+        std::cout << "Sample# " << rows + 1 << ": ";
+        std::vector<float> v(F);
+        for (size_t cols = 0; cols < F; cols++) std::cin >> v[cols];
+        data2[rows] = v;
+    }
 
-  std::vector<float> out = predict_OLS_regressor(data2, beta);
-  for (size_t rows = 0; rows < T; rows++)
-    std::cout << out[rows] << std::endl;
+    std::vector<float> out = predict_OLS_regressor(data2, beta);
+    for (size_t rows = 0; rows < T; rows++) std::cout << out[rows] << std::endl;
 
-  return 0;
+    return 0;
 }

From 880fc707fc29169c445e27ff5c66a6fcba71f428 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 00:09:17 -0400
Subject: [PATCH 042/290] cpp code docs optimize

---
 CMakeLists.txt | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b9c7831c8..bf1f1d3c7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -21,7 +21,10 @@ if(DOXYGEN_FOUND)
     set(DOXYGEN_CREATE_SUBDIRS YES)
     set(DOCYGEN_GENERATE_TREEVIEW YES)
     set(DOXYGEN_STRIP_CODE_COMMENTS NO)
-    set(DOXYGEN_OPTIMIZE_OUTPUT_FOR_C YES)
+    set(DOXYGEN_BUILTIN_STL_SUPPORT YES)
+    if(MSVC)
+        set(DOXYGEN_CPP_CLI_SUPPORT YES)
+    endif()
     set(DOXYGEN_MATHJAX_RELPATH "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-MML-AM_CHTML")
     if(Doxygen_dot_FOUND)
         set(DOXYGEN_HAVE_DOT YES)

From 79f53543b90449baa0bd5788a828e593a9caea02 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 00:21:06 -0400
Subject: [PATCH 043/290] added doxygen CI github action

---
 .github/workflows/gh-pages.yml | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 .github/workflows/gh-pages.yml

diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
new file mode 100644
index 000000000..aff5dcdce
--- /dev/null
+++ b/.github/workflows/gh-pages.yml
@@ -0,0 +1,35 @@
+name: Doxygen CI
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+        with:
+          submodules: true
+      - name: Install requirements
+        run: |
+          sudo apt -qq -y update
+          sudo apt -qq install doxygen graphviz ninja-build
+      - name: configure
+        run: cmake -G Ninja -B ./build -S .
+      - name: build
+        run: cmake --build build -t doc
+      - name: gh-pages
+        uses: actions/checkout@master
+        with:
+          ref: "gh-pages"
+          clean: false
+      - name: Move & Commit files
+        run: |
+          cp -rp ./build/html/* . && rm -rf ./build && ls -lah
+          git config --global user.name github-actions
+          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+          git add *
+          git commit -m "Documentation for $GITHUB_SHA" ||  true
+          git push --force || true

From 59a6db23cd530ab6ca04baf850febf2091390764 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 00:41:57 -0400
Subject: [PATCH 044/290] added CPP compile action

---
 .github/workflows/ccpp.yml | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 .github/workflows/ccpp.yml

diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
new file mode 100644
index 000000000..7eff58053
--- /dev/null
+++ b/.github/workflows/ccpp.yml
@@ -0,0 +1,27 @@
+name: C/C++ CI
+
+on: [push]
+#   push:
+#     branches: [ master ]
+#   pull_request:
+#     branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+
+    steps:
+    - uses: actions/checkout@master
+      with:
+        submodules: true
+    - name: Install requirements
+        run: sudo apt -qq install ninja-buil
+    - name: configure
+      run: cmake -G Ninja -B ./build -S .
+    - name: build
+      run: cmake --build build
+

From 22b375c058cf2eec6c47990ae1b46e08d6cdd3ee Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 00:49:27 -0400
Subject: [PATCH 045/290] fix cpp_lint bug

---
 .github/workflows/cpplint_modified_files.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/cpplint_modified_files.yml b/.github/workflows/cpplint_modified_files.yml
index 07a32ece9..8de6a5e41 100644
--- a/.github/workflows/cpplint_modified_files.yml
+++ b/.github/workflows/cpplint_modified_files.yml
@@ -11,7 +11,7 @@ jobs:
   cpplint_modified_files:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1  # v2 is broken for git diff
+      - uses: actions/checkout@v1 # v2 is broken for git diff
       - uses: actions/setup-python@v1
       - run: python -m pip install cpplint
       - run: git remote -v
@@ -42,7 +42,8 @@ jobs:
           print("g++:")
           # compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split())
           # compile_files = [file for file in cpp_files if file.lower().endswith(compile_exts)]
-          subprocess.run(["g++"] + cpp_files, check=True, text=True)
+          for cpp_file in cpp_files:
+            subprocess.run(["g++", cpp_file], check=True, text=True)
 
           upper_files = [file for file in cpp_files if file != file.lower()]
           if upper_files:

From dddcbee9ce2432b90f28ebf50aebe9500dcd854e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 00:52:38 -0400
Subject: [PATCH 046/290] fixed more filenames

---
 .../{Gaussian_elimination.cpp => gaussian_elimination.cpp}        | 0
 others/{Buzz_number.cpp => buzz_number.cpp}                       | 0
 others/{GCD_of_n_numbers.cpp => gcd_of_n_numbers.cpp}             | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename computer_oriented_statistical_methods/{Gaussian_elimination.cpp => gaussian_elimination.cpp} (100%)
 rename others/{Buzz_number.cpp => buzz_number.cpp} (100%)
 rename others/{GCD_of_n_numbers.cpp => gcd_of_n_numbers.cpp} (100%)

diff --git a/computer_oriented_statistical_methods/Gaussian_elimination.cpp b/computer_oriented_statistical_methods/gaussian_elimination.cpp
similarity index 100%
rename from computer_oriented_statistical_methods/Gaussian_elimination.cpp
rename to computer_oriented_statistical_methods/gaussian_elimination.cpp
diff --git a/others/Buzz_number.cpp b/others/buzz_number.cpp
similarity index 100%
rename from others/Buzz_number.cpp
rename to others/buzz_number.cpp
diff --git a/others/GCD_of_n_numbers.cpp b/others/gcd_of_n_numbers.cpp
similarity index 100%
rename from others/GCD_of_n_numbers.cpp
rename to others/gcd_of_n_numbers.cpp

From 9d64ff014e817d0f7f6442ab0b226b3c8f6464a8 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 04:52:59 +0000
Subject: [PATCH 047/290] updating DIRECTORY.md

---
 DIRECTORY.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 26210d6d4..b7f6ebdd5 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -12,7 +12,7 @@
 ## Computer Oriented Statistical Methods
   * [Bisection Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/bisection_method.cpp)
   * [False-Position](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/false-position.cpp)
-  * [Gaussian Elimination](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/Gaussian_elimination.cpp)
+  * [Gaussian Elimination](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/gaussian_elimination.cpp)
   * [Newton Raphson Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/newton_raphson_method.cpp)
   * [Ordinary Least Squares Regressor](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp)
   * [Secant Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/secant_method.cpp)
@@ -132,13 +132,13 @@
   * [Union Of 2 Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Union_of_2_arrays.cpp)
 
 ## Others
-  * [Buzz Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Buzz_number.cpp)
+  * [Buzz Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/buzz_number.cpp)
   * [Decimal To Binary](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_binary.cpp)
   * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_hexadecimal.cpp)
   * [Decimal To Roman Numeral](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_roman_numeral.cpp)
   * [Fast Interger Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_interger_input.cpp)
   * [Fibonacci Fast](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_fast.cpp)
-  * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/GCD_of_n_numbers.cpp)
+  * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/gcd_of_n_numbers.cpp)
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
   * [Measure Time Elapsed](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/measure_time_elapsed.cpp)

From ecffb77f86164cc0ec4d2614df7239abd65f21e9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 00:54:03 -0400
Subject: [PATCH 048/290] remove dash from filename

---
 .../{false-position.cpp => false_position.cpp}                    | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename computer_oriented_statistical_methods/{false-position.cpp => false_position.cpp} (100%)

diff --git a/computer_oriented_statistical_methods/false-position.cpp b/computer_oriented_statistical_methods/false_position.cpp
similarity index 100%
rename from computer_oriented_statistical_methods/false-position.cpp
rename to computer_oriented_statistical_methods/false_position.cpp

From f28099d3f86dd18fc1f9e02aa13b837a9dab13a7 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 04:54:27 +0000
Subject: [PATCH 049/290] updating DIRECTORY.md

---
 DIRECTORY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index b7f6ebdd5..9e163d414 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -11,7 +11,7 @@
 
 ## Computer Oriented Statistical Methods
   * [Bisection Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/bisection_method.cpp)
-  * [False-Position](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/false-position.cpp)
+  * [False Position](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/false_position.cpp)
   * [Gaussian Elimination](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/gaussian_elimination.cpp)
   * [Newton Raphson Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/newton_raphson_method.cpp)
   * [Ordinary Least Squares Regressor](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp)

From 7bb69e4183dda6dff56719b0f63c168670d5cbd0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 01:17:12 -0400
Subject: [PATCH 050/290] added documentation equations

---
 .../ordinary_least_squares_regressor.cpp                 | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
index 41acfa10a..06bd4ea52 100644
--- a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
+++ b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
@@ -294,7 +294,8 @@ std::vector<std::vector<T>> get_transpose(
 }
 
 /**
- * Perform Ordinary Least Squares curve fit.
+ * Perform Ordinary Least Squares curve fit. This operation is defined as
+ * \f[\beta = \left(X^TXX^T\right)Y\f]
  * \param X feature matrix with rows representing sample vector of features
  * \param Y known regression value for each sample
  * \returns fitted regression model polynomial coefficients
@@ -322,9 +323,11 @@ std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
 
 /**
  * Given data and OLS model coeffficients, predict
- * regression estimates.
+ * regression estimates. This operation is defined as
+ * \f[y_{\text{row}=i} = \sum_{j=\text{columns}}\beta_j\cdot X_{i,j}\f]
+ *
  * \param X feature matrix with rows representing sample vector of features
- * \param \f$\beta\f$ fitted regression model
+ * \param beta fitted regression model
  * \return vector with regression values for each sample
  **/
 template <typename T>

From c4e49b95578d632f2a9524ae36ef2518f92ca0d1 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 01:17:30 -0400
Subject: [PATCH 051/290] project description correction

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index bf1f1d3c7..ff568fc9d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.3)
 project(Algorithms_in_C++
     LANGUAGES CXX
     VERSION 1.0.0
-    DESCRIPTION "Set of algorithms implemented in C."
+    DESCRIPTION "Set of algorithms implemented in C++."
 )
 
 # set(CMAKE_CXX_CPPLINT "~/anaconda3/bin/cpplint --filter=-legal/copyright --std=c++11")

From 06fe0efc9429ab72787faa5d6317aff9593b414b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 01:18:59 -0400
Subject: [PATCH 052/290] yml file indentation correction

---
 .github/workflows/ccpp.yml | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
index 7eff58053..392c8bd8f 100644
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -8,20 +8,18 @@ on: [push]
 
 jobs:
   build:
-
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
 
     steps:
-    - uses: actions/checkout@master
-      with:
-        submodules: true
-    - name: Install requirements
-        run: sudo apt -qq install ninja-buil
-    - name: configure
-      run: cmake -G Ninja -B ./build -S .
-    - name: build
-      run: cmake --build build
-
+      - uses: actions/checkout@master
+        with:
+          submodules: true
+      - name: Install requirements
+        run: sudo apt -qq install ninja-build
+      - name: configure
+        run: cmake -G Ninja -B ./build -S .
+      - name: build
+        run: cmake --build build

From 249b91d5ff4af928711f7d9b411f4e3e2fd961d9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 01:21:32 -0400
Subject: [PATCH 053/290] remove install ninja

---
 .github/workflows/ccpp.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
index 392c8bd8f..30b8edf19 100644
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -17,8 +17,6 @@ jobs:
       - uses: actions/checkout@master
         with:
           submodules: true
-      - name: Install requirements
-        run: sudo apt -qq install ninja-build
       - name: configure
         run: cmake -G Ninja -B ./build -S .
       - name: build

From 65d4fe035a2c101b6471e3cf8f6080cca243ed41 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 01:22:46 -0400
Subject: [PATCH 054/290] remove ninja as cmake generator

---
 .github/workflows/ccpp.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
index 30b8edf19..34085cdec 100644
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -18,6 +18,6 @@ jobs:
         with:
           submodules: true
       - name: configure
-        run: cmake -G Ninja -B ./build -S .
+        run: cmake -B ./build -S .
       - name: build
         run: cmake --build build

From 0163e6a34d898c7a8be1791b53252b5c3d1d3dee Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Tue, 26 May 2020 01:29:51 -0400
Subject: [PATCH 055/290] added CI badges

---
 README.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/README.md b/README.md
index a3077cdc5..04feb9c52 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,9 @@
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
 ![GitHub repo size](https://img.shields.io/github/repo-size/TheAlgorithms/C-Plus-Plus?color=red&style=flat-square)
 ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/TheAlgorithms/C-Plus-Plus?color=green&style=flat-square)
+![Doxygen CI](https://github.com/kvedala/C-Plus-Plus/workflows/Doxygen%20CI/badge.svg)
+![cpplint](https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg)
+![C/C++ CI](https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg)
 
 ### All algorithms implemented in C++ (for education)
 The implementations are for learning purpose. They may be less efficient than the implementation in the standard library.

From 10da051ba6673e09af3328bbee96e7f1d202f540 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Tue, 26 May 2020 01:31:58 -0400
Subject: [PATCH 056/290] added documentation URL

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 04feb9c52..e8034d7c4 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,8 @@
 ![cpplint](https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg)
 ![C/C++ CI](https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg)
 
+[Documentation](https://kvedala.github.io/C-Plus-Plus)
+
 ### All algorithms implemented in C++ (for education)
 The implementations are for learning purpose. They may be less efficient than the implementation in the standard library.
 

From 614ea8eb5841199d86c40414935e68e10bc3b918 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 08:48:09 -0400
Subject: [PATCH 057/290] newline character at EOF of gitignore

---
 .gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 12318c6cd..5275088d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,4 +34,4 @@ a.out
 *.out
 *.app
 
-build/
\ No newline at end of file
+build/

From 0ad756f8609efdb5fd3d27508fa692c738fc1fc7 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:05:29 -0400
Subject: [PATCH 058/290] `rand_r` is non-portable and obsolete

---
 math/fast_power.cpp | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index 4f6e02081..5dd724085 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -50,30 +50,28 @@ double fast_power_linear(int64_t a, int64_t b) {
 }
 
 int main() {
-    std::srand(time(NULL));
+    std::srand(std::time(nullptr));
     std::ios_base::sync_with_stdio(false);
 
     std::cout << "Testing..." << std::endl;
     for (int i = 0; i < 20; i++) {
-        unsigned int *rand1, *rand2;
-        int a = rand_r(rand1) % 20 - 10;
-        int b = rand_r(rand2) % 20 - 10;
+        int a = std::rand() % 20 - 10;
+        int b = std::rand() % 20 - 10;
         std::cout << std::endl << "Calculating " << a << "^" << b << std::endl;
         assert(fast_power_recursive(a, b) == std::pow(a, b));
         assert(fast_power_linear(a, b) == std::pow(a, b));
 
-        std::cout << "------ " << a << "^" << b << " = "<<
-            fast_power_recursive(a, b) << std::endl;
+        std::cout << "------ " << a << "^" << b << " = "
+                  << fast_power_recursive(a, b) << std::endl;
     }
 
     int64_t a, b;
     std::cin >> a >> b;
 
-    std::cout << a << "^" << b << " = "<<
-        fast_power_recursive(a, b) << std::endl;
+    std::cout << a << "^" << b << " = " << fast_power_recursive(a, b)
+              << std::endl;
 
-    std::cout << a << "^" << b << " = "<<
-        fast_power_linear(a, b) << std::endl;
+    std::cout << a << "^" << b << " = " << fast_power_linear(a, b) << std::endl;
 
     return 0;
 }

From 139964d32563b3c92e0651bf46350e107391c5a5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:05:44 -0400
Subject: [PATCH 059/290] improved documentation

---
 math/fast_power.cpp | 40 +++++++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index 5dd724085..0ffbcd40d 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -1,22 +1,29 @@
-#include <iostream>
-#include <cstdlib>
-#include <cstdint>
-#include <cassert>
-#include <ctime>
-#include <cmath>
-
-/*
-    Program that computes a^b in O(logN) time.
+/**
+ * @file
+    Program that computes \f$a^b\f$ in \f$O(logN)\f$ time.
     It is based on formula that:
-        case1) if b is even: a^b = a^(b/2) * a^(b/2) = (a^(b/2))ˆ2
-        case2) if b is odd: a^b = a^((b-1)/2) * a^((b-1)/2) * a = (a^((b-1)/2))^2 * a
-    We can compute a^b recursively using above algorithm.
+    1. if \f$b\f$ is even: \f$a^b = a^\frac{b}{2} \cdot a^\frac{b}{2} =
+ {a^\frac{b}{2}}^2\f$
+    2. if \f$b\f$ is odd: \f$a^b = a^\frac{b-1}{2} \cdot
+ a^\frac{b-1}{2} \cdot a = {a^\frac{b-1}{2}}^2 \cdot a\f$
+
+ We can compute \f$a^b\f$
+ recursively using above algorithm.
 */
 
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+
+/**
+ * algorithm implementation for \f$a^b\f$
+ */
 double fast_power_recursive(int64_t a, int64_t b) {
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0)
-        return 1.0 / fast_power_recursive(a, -b);
+    if (b < 0) return 1.0 / fast_power_recursive(a, -b);
 
     if (b == 0) return 1;
     int64_t bottom = fast_power_recursive(a, b >> 1);
@@ -31,14 +38,13 @@ double fast_power_recursive(int64_t a, int64_t b) {
     return result;
 }
 
-/*
+/**
     Same algorithm with little different formula.
     It still calculates in O(logN)
 */
 double fast_power_linear(int64_t a, int64_t b) {
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0)
-        return 1.0 / fast_power_linear(a, -b);
+    if (b < 0) return 1.0 / fast_power_linear(a, -b);
 
     double result = 1;
     while (b) {

From 2def9abcc2306ab569687f85f1802c4e5493d244 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:10:28 -0400
Subject: [PATCH 060/290] cin accepts only one variable at a time & fixed
 cpplint

---
 others/sparse_matrix.cpp | 65 ++++++++++++++++++++--------------------
 1 file changed, 32 insertions(+), 33 deletions(-)

diff --git a/others/sparse_matrix.cpp b/others/sparse_matrix.cpp
index 1861163f1..de4759a3e 100644
--- a/others/sparse_matrix.cpp
+++ b/others/sparse_matrix.cpp
@@ -1,41 +1,40 @@
-/*A sparse matrix is a matrix which has number of zeroes greater than (m*n)/2,
-where m and n are the dimensions of the matrix.*/
+/** @file
+ * A sparse matrix is a matrix which has number of zeroes greater than
+ * \f$\frac{m*n}{2}\f$, where m and n are the dimensions of the matrix.
+ */
+
 #include <iostream>
-using namespace std;
 
-int main()
-{
-  int m, n;
-  int counterZeros = 0;
-  cout << "Enter dimensions of matrix (seperated with space): ";
-  cin >> m >> n;
-  int a[m][n];
-  cout << "Enter matrix elements:";
-  cout << "\n";
+int main() {
+    int m, n;
+    int counterZeros = 0;
 
-  // reads the matrix from stdin
-  for (int i = 0; i < m; i++)
-  {
-    for (int j = 0; j < n; j++)
-    {
-      cout << "element? ";
-      cin >> a[i][j];
+    std::cout << "Enter dimensions of matrix (seperated with space): ";
+    std::cin >> m;
+    std::cin >> n;
+
+    int a[m][n];
+    std::cout << "Enter matrix elements:";
+    std::cout << "\n";
+
+    // reads the matrix from stdin
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            std::cout << "element? ";
+            std::cin >> a[i][j];
+        }
     }
-  }
 
-  // counts the zero's
-  for (int i = 0; i < m; i++)
-  {
-    for (int j = 0; j < n; j++)
-    {
-      if (a[i][j] == 0)
-        counterZeros++; //Counting number of zeroes
+    // counts the zero's
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (a[i][j] == 0) counterZeros++;  // Counting number of zeroes
+        }
     }
-  }
 
-  // makes sure the matrix is a sparse matrix
-  if (counterZeros > ((m * n) / 2)) //Checking for sparse matrix
-    cout << "Sparse matrix";
-  else
-    cout << "Not a sparse matrix";
+    // makes sure the matrix is a sparse matrix
+    if (counterZeros > ((m * n) / 2))  // Checking for sparse matrix
+        std::cout << "Sparse matrix";
+    else
+        std::cout << "Not a sparse matrix";
 }

From d6d328c8c9a760b86e61b6e3e491a6a4416926db Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:25:42 -0400
Subject: [PATCH 061/290] file rename

---
 others/{Palindromeofnumber.cpp => palindrome_of_number.cpp} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename others/{Palindromeofnumber.cpp => palindrome_of_number.cpp} (100%)

diff --git a/others/Palindromeofnumber.cpp b/others/palindrome_of_number.cpp
similarity index 100%
rename from others/Palindromeofnumber.cpp
rename to others/palindrome_of_number.cpp

From fb3a8091f9492ccac9b66572612e39e394eed4ad Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:26:40 -0400
Subject: [PATCH 062/290] fixed lint

---
 others/palindrome_of_number.cpp | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index 647803997..dda872882 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -1,23 +1,20 @@
-#include <iostream>
 #include <algorithm>
+#include <iostream>
 
-using namespace std;
+int main() {
+    int num;
+    std::cout << "Enter number = ";
+    std::cin >> num;
 
-int main()
-{
-	int num;
-	cout << "Enter number = ";
-	cin >> num;
+    std::string s1 = std::to_string(num);
+    std::string s2 = s1;
 
-	string s1 = to_string(num);
-	string s2 = s1;
+    reverse(s1.begin(), s1.end());
 
-	reverse(s1.begin(), s1.end());
+    if (s1 == s2)
+        std::cout << "true";
+    else
+        std::cout << "false";
 
-	if (s1 == s2)
-		cout << "true";
-	else
-		cout << "false";
-
-	return 0;
+    return 0;
 }

From 4b25222d430a3be8b2072cd671df7513412c8a5c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:32:37 -0400
Subject: [PATCH 063/290] fixed windows build error

---
 .../gaussian_elimination.cpp                       | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/computer_oriented_statistical_methods/gaussian_elimination.cpp b/computer_oriented_statistical_methods/gaussian_elimination.cpp
index ecfbfacc9..0b8bb693d 100644
--- a/computer_oriented_statistical_methods/gaussian_elimination.cpp
+++ b/computer_oriented_statistical_methods/gaussian_elimination.cpp
@@ -6,7 +6,11 @@ int main() {
     std::cout << "Matrix size: ";
     std::cin >> mat_size;
 
-    double mat[mat_size + 1][mat_size + 1], x[mat_size][mat_size + 1];
+    double **mat = new double *[mat_size + 1], **x = new double *[mat_size];
+    for (i = 0; i <= mat_size; i++) {
+        mat[i] = new double[mat_size + 1];
+        if (i < mat_size) x[i] = new double[mat_size + 1];
+    }
 
     std::cout << std::endl << "Enter value of the matrix: " << std::endl;
     for (i = 0; i < mat_size; i++) {
@@ -49,5 +53,13 @@ int main() {
 
         std::cout << "x" << i << "= " << x[i][i] << std::endl;
     }
+
+    for (i = 0; i <= mat_size; i++) {
+        delete[] mat[i];
+        if (i < mat_size) delete[] x[i];
+    }
+    delete[] mat;
+    delete[] x;
+
     return 0;
 }

From a3a57aea2d1aee64f7e9ce5e0b7f3eac686642ce Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 13:33:02 +0000
Subject: [PATCH 064/290] updating DIRECTORY.md

---
 DIRECTORY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 9e163d414..7b0fb2b6b 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -142,7 +142,7 @@
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
   * [Measure Time Elapsed](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/measure_time_elapsed.cpp)
-  * [Palindromeofnumber](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Palindromeofnumber.cpp)
+  * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/palindrome_of_number.cpp)
   * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)
   * [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp)
   * [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/primality_test.cpp)

From 899be6a1f17e4f1bd1e7fee6375432767757cc0b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:35:25 -0400
Subject: [PATCH 065/290] removed in-favor of chronos library of c++11

---
 others/measure_time_elapsed.cpp | 19 -------------------
 1 file changed, 19 deletions(-)
 delete mode 100644 others/measure_time_elapsed.cpp

diff --git a/others/measure_time_elapsed.cpp b/others/measure_time_elapsed.cpp
deleted file mode 100644
index d0830ab79..000000000
--- a/others/measure_time_elapsed.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// To calculate the time taken by a code to execute
-#include <sys/time.h>
-#include <iostream>
-
-__int64_t getTimeInMicroseconds() {
-    struct timeval start;
-    gettimeofday(&start, NULL);
-    return start.tv_sec * 1000000 + start.tv_usec;
-}
-
-// write function sample(args)
-
-int main() {
-    // write code
-    __int64_t starttime = getTimeInMicroseconds();
-    // sample(args) function run
-    // Any other functions (if present) run
-    std::cout << getTimeInMicroseconds() - starttime;
-}

From dd20bf94427392ea0baa428ecf2587d6a8a7a131 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:37:36 -0400
Subject: [PATCH 066/290] fixed dynamic array

---
 others/sparse_matrix.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/others/sparse_matrix.cpp b/others/sparse_matrix.cpp
index de4759a3e..d9878fda4 100644
--- a/others/sparse_matrix.cpp
+++ b/others/sparse_matrix.cpp
@@ -13,7 +13,9 @@ int main() {
     std::cin >> m;
     std::cin >> n;
 
-    int a[m][n];
+    int **a = new int *[m];
+    for (int i = 0; i < m; i++) a[i] = new int[n];
+
     std::cout << "Enter matrix elements:";
     std::cout << "\n";
 
@@ -37,4 +39,8 @@ int main() {
         std::cout << "Sparse matrix";
     else
         std::cout << "Not a sparse matrix";
+
+    for (int i = 0; i < m; i++) delete[] a[i];
+    delete[] a;
+    return 0;
 }

From 3d5a6fbce3f7ad219c2946e6faeb03335e66367d Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 13:40:20 +0000
Subject: [PATCH 067/290] updating DIRECTORY.md

---
 DIRECTORY.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 7b0fb2b6b..47842b9ca 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -141,7 +141,6 @@
   * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/gcd_of_n_numbers.cpp)
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
-  * [Measure Time Elapsed](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/measure_time_elapsed.cpp)
   * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/palindrome_of_number.cpp)
   * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)
   * [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp)

From 2217049119a2ecfcd7f2aad8feae03594be0787c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:40:57 -0400
Subject: [PATCH 068/290] add cstring for std::to_string()

---
 others/palindrome_of_number.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index dda872882..93c54a965 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <cstring>
 #include <iostream>
 
 int main() {

From fdee12d82af42f86a3df5964a6be4182084bbe26 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:50:41 -0400
Subject: [PATCH 069/290] remove redundant /Za for VC

---
 CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ff568fc9d..14079562a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -45,7 +45,6 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(MSVC)
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
-    add_compile_options(/Za)
 endif(MSVC)
 
 add_subdirectory(math)

From 8bc1559b082454a397cd6f8f0104a7cc0c0b7737 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 10:00:09 -0400
Subject: [PATCH 070/290] for windows build, MSVC knows C++-14 and not 11

---
 CMakeLists.txt | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 14079562a..4394f84e1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,6 +8,14 @@ project(Algorithms_in_C++
 # set(CMAKE_CXX_CPPLINT "~/anaconda3/bin/cpplint --filter=-legal/copyright --std=c++11")
 # find_program(CLANG_FORMAT "clang-format")
 
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(MSVC)
+    set(CMAKE_CXX_STANDARD 14)
+    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+endif(MSVC)
+
 option(USE_OPENMP "flag to use OpenMP for multithreading" ON)
 
 cmake_policy(SET CMP0054 NEW)
@@ -40,20 +48,13 @@ if(DOXYGEN_FOUND)
     )
 endif()
 
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-if(MSVC)
-    add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
-endif(MSVC)
-
 add_subdirectory(math)
 add_subdirectory(others)
 add_subdirectory(computer_oriented_statistical_methods)
 
 if(USE_OPENMP)
     find_package(OpenMP)
-    if (OpenMP_C_FOUND)
+    if (OpenMP_CXX_FOUND)
         message(STATUS "Building with OpenMP Multithreading.")
     else()
         message(STATUS "No OpenMP found, no multithreading.")

From fe9d2b9bc66ee9f2e5112ced6b6d5aab7d5e5f05 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 10:06:01 -0400
Subject: [PATCH 071/290] MSVC does not know cstring-use string-for toString

---
 others/palindrome_of_number.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index 93c54a965..621b09ab6 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -1,7 +1,13 @@
 #include <algorithm>
-#include <cstring>
 #include <iostream>
 
+#ifdef _MSC_VER
+// Required to compile std::toString function using MSVC
+#include <string>
+#else
+#include <cstring>
+#endif
+
 int main() {
     int num;
     std::cout << "Enter number = ";

From a6319c5f43d019a23a8eb3ffa48f6b8a30ff85a4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 08:48:09 -0400
Subject: [PATCH 072/290] newline character at EOF of gitignore

(cherry picked from commit 614ea8eb5841199d86c40414935e68e10bc3b918)
---
 .gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 12318c6cd..5275088d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,4 +34,4 @@ a.out
 *.out
 *.app
 
-build/
\ No newline at end of file
+build/

From 36b4d59d5914f1c35f09f82cab65514a48166fa7 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:05:29 -0400
Subject: [PATCH 073/290] `rand_r` is non-portable and obsolete

(cherry picked from commit 0ad756f8609efdb5fd3d27508fa692c738fc1fc7)
---
 math/fast_power.cpp | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index 4f6e02081..5dd724085 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -50,30 +50,28 @@ double fast_power_linear(int64_t a, int64_t b) {
 }
 
 int main() {
-    std::srand(time(NULL));
+    std::srand(std::time(nullptr));
     std::ios_base::sync_with_stdio(false);
 
     std::cout << "Testing..." << std::endl;
     for (int i = 0; i < 20; i++) {
-        unsigned int *rand1, *rand2;
-        int a = rand_r(rand1) % 20 - 10;
-        int b = rand_r(rand2) % 20 - 10;
+        int a = std::rand() % 20 - 10;
+        int b = std::rand() % 20 - 10;
         std::cout << std::endl << "Calculating " << a << "^" << b << std::endl;
         assert(fast_power_recursive(a, b) == std::pow(a, b));
         assert(fast_power_linear(a, b) == std::pow(a, b));
 
-        std::cout << "------ " << a << "^" << b << " = "<<
-            fast_power_recursive(a, b) << std::endl;
+        std::cout << "------ " << a << "^" << b << " = "
+                  << fast_power_recursive(a, b) << std::endl;
     }
 
     int64_t a, b;
     std::cin >> a >> b;
 
-    std::cout << a << "^" << b << " = "<<
-        fast_power_recursive(a, b) << std::endl;
+    std::cout << a << "^" << b << " = " << fast_power_recursive(a, b)
+              << std::endl;
 
-    std::cout << a << "^" << b << " = "<<
-        fast_power_linear(a, b) << std::endl;
+    std::cout << a << "^" << b << " = " << fast_power_linear(a, b) << std::endl;
 
     return 0;
 }

From 05ec7bed7282997e36dec1f7dd5273e85e46834c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:05:44 -0400
Subject: [PATCH 074/290] improved documentation

(cherry picked from commit 139964d32563b3c92e0651bf46350e107391c5a5)
---
 math/fast_power.cpp | 40 +++++++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index 5dd724085..0ffbcd40d 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -1,22 +1,29 @@
-#include <iostream>
-#include <cstdlib>
-#include <cstdint>
-#include <cassert>
-#include <ctime>
-#include <cmath>
-
-/*
-    Program that computes a^b in O(logN) time.
+/**
+ * @file
+    Program that computes \f$a^b\f$ in \f$O(logN)\f$ time.
     It is based on formula that:
-        case1) if b is even: a^b = a^(b/2) * a^(b/2) = (a^(b/2))ˆ2
-        case2) if b is odd: a^b = a^((b-1)/2) * a^((b-1)/2) * a = (a^((b-1)/2))^2 * a
-    We can compute a^b recursively using above algorithm.
+    1. if \f$b\f$ is even: \f$a^b = a^\frac{b}{2} \cdot a^\frac{b}{2} =
+ {a^\frac{b}{2}}^2\f$
+    2. if \f$b\f$ is odd: \f$a^b = a^\frac{b-1}{2} \cdot
+ a^\frac{b-1}{2} \cdot a = {a^\frac{b-1}{2}}^2 \cdot a\f$
+
+ We can compute \f$a^b\f$
+ recursively using above algorithm.
 */
 
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+
+/**
+ * algorithm implementation for \f$a^b\f$
+ */
 double fast_power_recursive(int64_t a, int64_t b) {
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0)
-        return 1.0 / fast_power_recursive(a, -b);
+    if (b < 0) return 1.0 / fast_power_recursive(a, -b);
 
     if (b == 0) return 1;
     int64_t bottom = fast_power_recursive(a, b >> 1);
@@ -31,14 +38,13 @@ double fast_power_recursive(int64_t a, int64_t b) {
     return result;
 }
 
-/*
+/**
     Same algorithm with little different formula.
     It still calculates in O(logN)
 */
 double fast_power_linear(int64_t a, int64_t b) {
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0)
-        return 1.0 / fast_power_linear(a, -b);
+    if (b < 0) return 1.0 / fast_power_linear(a, -b);
 
     double result = 1;
     while (b) {

From 5fddd6c7cd3d8deb2d8e135c3fe3d11586244957 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:10:28 -0400
Subject: [PATCH 075/290] cin accepts only one variable at a time & fixed
 cpplint

(cherry picked from commit 2def9abcc2306ab569687f85f1802c4e5493d244)
---
 others/sparse_matrix.cpp | 65 ++++++++++++++++++++--------------------
 1 file changed, 32 insertions(+), 33 deletions(-)

diff --git a/others/sparse_matrix.cpp b/others/sparse_matrix.cpp
index 1861163f1..de4759a3e 100644
--- a/others/sparse_matrix.cpp
+++ b/others/sparse_matrix.cpp
@@ -1,41 +1,40 @@
-/*A sparse matrix is a matrix which has number of zeroes greater than (m*n)/2,
-where m and n are the dimensions of the matrix.*/
+/** @file
+ * A sparse matrix is a matrix which has number of zeroes greater than
+ * \f$\frac{m*n}{2}\f$, where m and n are the dimensions of the matrix.
+ */
+
 #include <iostream>
-using namespace std;
 
-int main()
-{
-  int m, n;
-  int counterZeros = 0;
-  cout << "Enter dimensions of matrix (seperated with space): ";
-  cin >> m >> n;
-  int a[m][n];
-  cout << "Enter matrix elements:";
-  cout << "\n";
+int main() {
+    int m, n;
+    int counterZeros = 0;
 
-  // reads the matrix from stdin
-  for (int i = 0; i < m; i++)
-  {
-    for (int j = 0; j < n; j++)
-    {
-      cout << "element? ";
-      cin >> a[i][j];
+    std::cout << "Enter dimensions of matrix (seperated with space): ";
+    std::cin >> m;
+    std::cin >> n;
+
+    int a[m][n];
+    std::cout << "Enter matrix elements:";
+    std::cout << "\n";
+
+    // reads the matrix from stdin
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            std::cout << "element? ";
+            std::cin >> a[i][j];
+        }
     }
-  }
 
-  // counts the zero's
-  for (int i = 0; i < m; i++)
-  {
-    for (int j = 0; j < n; j++)
-    {
-      if (a[i][j] == 0)
-        counterZeros++; //Counting number of zeroes
+    // counts the zero's
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
+            if (a[i][j] == 0) counterZeros++;  // Counting number of zeroes
+        }
     }
-  }
 
-  // makes sure the matrix is a sparse matrix
-  if (counterZeros > ((m * n) / 2)) //Checking for sparse matrix
-    cout << "Sparse matrix";
-  else
-    cout << "Not a sparse matrix";
+    // makes sure the matrix is a sparse matrix
+    if (counterZeros > ((m * n) / 2))  // Checking for sparse matrix
+        std::cout << "Sparse matrix";
+    else
+        std::cout << "Not a sparse matrix";
 }

From 5f8b270992e4b6f344aa50b78a92236c8e48a48b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:25:42 -0400
Subject: [PATCH 076/290] file rename

(cherry picked from commit d6d328c8c9a760b86e61b6e3e491a6a4416926db)
---
 others/{Palindromeofnumber.cpp => palindrome_of_number.cpp} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename others/{Palindromeofnumber.cpp => palindrome_of_number.cpp} (100%)

diff --git a/others/Palindromeofnumber.cpp b/others/palindrome_of_number.cpp
similarity index 100%
rename from others/Palindromeofnumber.cpp
rename to others/palindrome_of_number.cpp

From 59be834836c839db7fba0ab852193252e6fa3eeb Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:26:40 -0400
Subject: [PATCH 077/290] fixed lint

(cherry picked from commit fb3a8091f9492ccac9b66572612e39e394eed4ad)
---
 others/palindrome_of_number.cpp | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index 647803997..dda872882 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -1,23 +1,20 @@
-#include <iostream>
 #include <algorithm>
+#include <iostream>
 
-using namespace std;
+int main() {
+    int num;
+    std::cout << "Enter number = ";
+    std::cin >> num;
 
-int main()
-{
-	int num;
-	cout << "Enter number = ";
-	cin >> num;
+    std::string s1 = std::to_string(num);
+    std::string s2 = s1;
 
-	string s1 = to_string(num);
-	string s2 = s1;
+    reverse(s1.begin(), s1.end());
 
-	reverse(s1.begin(), s1.end());
+    if (s1 == s2)
+        std::cout << "true";
+    else
+        std::cout << "false";
 
-	if (s1 == s2)
-		cout << "true";
-	else
-		cout << "false";
-
-	return 0;
+    return 0;
 }

From 48473295275ad3b1911365f0216249d44e3afe8b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:32:37 -0400
Subject: [PATCH 078/290] fixed windows build error

(cherry picked from commit 4b25222d430a3be8b2072cd671df7513412c8a5c)
---
 .../gaussian_elimination.cpp                       | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/computer_oriented_statistical_methods/gaussian_elimination.cpp b/computer_oriented_statistical_methods/gaussian_elimination.cpp
index ecfbfacc9..0b8bb693d 100644
--- a/computer_oriented_statistical_methods/gaussian_elimination.cpp
+++ b/computer_oriented_statistical_methods/gaussian_elimination.cpp
@@ -6,7 +6,11 @@ int main() {
     std::cout << "Matrix size: ";
     std::cin >> mat_size;
 
-    double mat[mat_size + 1][mat_size + 1], x[mat_size][mat_size + 1];
+    double **mat = new double *[mat_size + 1], **x = new double *[mat_size];
+    for (i = 0; i <= mat_size; i++) {
+        mat[i] = new double[mat_size + 1];
+        if (i < mat_size) x[i] = new double[mat_size + 1];
+    }
 
     std::cout << std::endl << "Enter value of the matrix: " << std::endl;
     for (i = 0; i < mat_size; i++) {
@@ -49,5 +53,13 @@ int main() {
 
         std::cout << "x" << i << "= " << x[i][i] << std::endl;
     }
+
+    for (i = 0; i <= mat_size; i++) {
+        delete[] mat[i];
+        if (i < mat_size) delete[] x[i];
+    }
+    delete[] mat;
+    delete[] x;
+
     return 0;
 }

From 8cb310a9fce0c50101487c4f559a6db3d79290c0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:35:25 -0400
Subject: [PATCH 079/290] removed in-favor of chronos library of c++11

(cherry picked from commit 899be6a1f17e4f1bd1e7fee6375432767757cc0b)
---
 others/measure_time_elapsed.cpp | 19 -------------------
 1 file changed, 19 deletions(-)
 delete mode 100644 others/measure_time_elapsed.cpp

diff --git a/others/measure_time_elapsed.cpp b/others/measure_time_elapsed.cpp
deleted file mode 100644
index d0830ab79..000000000
--- a/others/measure_time_elapsed.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// To calculate the time taken by a code to execute
-#include <sys/time.h>
-#include <iostream>
-
-__int64_t getTimeInMicroseconds() {
-    struct timeval start;
-    gettimeofday(&start, NULL);
-    return start.tv_sec * 1000000 + start.tv_usec;
-}
-
-// write function sample(args)
-
-int main() {
-    // write code
-    __int64_t starttime = getTimeInMicroseconds();
-    // sample(args) function run
-    // Any other functions (if present) run
-    std::cout << getTimeInMicroseconds() - starttime;
-}

From 64c8bf38bdb214c9a0eb1e3c6c2f0245e9dcad78 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 09:37:36 -0400
Subject: [PATCH 080/290] fixed dynamic array

(cherry picked from commit dd20bf94427392ea0baa428ecf2587d6a8a7a131)
---
 others/sparse_matrix.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/others/sparse_matrix.cpp b/others/sparse_matrix.cpp
index de4759a3e..d9878fda4 100644
--- a/others/sparse_matrix.cpp
+++ b/others/sparse_matrix.cpp
@@ -13,7 +13,9 @@ int main() {
     std::cin >> m;
     std::cin >> n;
 
-    int a[m][n];
+    int **a = new int *[m];
+    for (int i = 0; i < m; i++) a[i] = new int[n];
+
     std::cout << "Enter matrix elements:";
     std::cout << "\n";
 
@@ -37,4 +39,8 @@ int main() {
         std::cout << "Sparse matrix";
     else
         std::cout << "Not a sparse matrix";
+
+    for (int i = 0; i < m; i++) delete[] a[i];
+    delete[] a;
+    return 0;
 }

From a15b5c5a9ba954c112e8e599e7885d9afb297ac0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 10:06:01 -0400
Subject: [PATCH 081/290] MSVC does not know cstring-use string-for toString

(cherry picked from commit fe9d2b9bc66ee9f2e5112ced6b6d5aab7d5e5f05)
---
 others/palindrome_of_number.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index dda872882..621b09ab6 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -1,6 +1,13 @@
 #include <algorithm>
 #include <iostream>
 
+#ifdef _MSC_VER
+// Required to compile std::toString function using MSVC
+#include <string>
+#else
+#include <cstring>
+#endif
+
 int main() {
     int num;
     std::cout << "Enter number = ";

From cfe9142c92e7cabc763b0c931f6bec5548c46c0a Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 14:18:48 +0000
Subject: [PATCH 082/290] updating DIRECTORY.md

---
 DIRECTORY.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 9e163d414..47842b9ca 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -141,8 +141,7 @@
   * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/gcd_of_n_numbers.cpp)
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
-  * [Measure Time Elapsed](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/measure_time_elapsed.cpp)
-  * [Palindromeofnumber](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/Palindromeofnumber.cpp)
+  * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/palindrome_of_number.cpp)
   * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)
   * [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp)
   * [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/primality_test.cpp)

From 62ff9fb19b97c34fdaf5fc4e06c32886542696a8 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 10:57:46 -0400
Subject: [PATCH 083/290] add cmake to strings folder remove CXX-14 standard
 for MSVC

---
 CMakeLists.txt         |  3 ++-
 strings/CMakeLists.txt | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 strings/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4394f84e1..ab633b827 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,7 +12,7 @@ set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(MSVC)
-    set(CMAKE_CXX_STANDARD 14)
+    # set(CMAKE_CXX_STANDARD 14)
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif(MSVC)
 
@@ -50,6 +50,7 @@ endif()
 
 add_subdirectory(math)
 add_subdirectory(others)
+add_subdirectory(strings)
 add_subdirectory(computer_oriented_statistical_methods)
 
 if(USE_OPENMP)
diff --git a/strings/CMakeLists.txt b/strings/CMakeLists.txt
new file mode 100644
index 000000000..3c15695cc
--- /dev/null
+++ b/strings/CMakeLists.txt
@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/strings")
+
+endforeach( testsourcefile ${APP_SOURCES} )

From 3f5c524722ce29723c17513d4507004a7b7bfe41 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 10:57:46 -0400
Subject: [PATCH 084/290] add cmake to strings folder remove CXX-14 standard
 for MSVC

---
 CMakeLists.txt         |  3 ++-
 strings/CMakeLists.txt | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 strings/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4394f84e1..ab633b827 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,7 +12,7 @@ set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if(MSVC)
-    set(CMAKE_CXX_STANDARD 14)
+    # set(CMAKE_CXX_STANDARD 14)
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif(MSVC)
 
@@ -50,6 +50,7 @@ endif()
 
 add_subdirectory(math)
 add_subdirectory(others)
+add_subdirectory(strings)
 add_subdirectory(computer_oriented_statistical_methods)
 
 if(USE_OPENMP)
diff --git a/strings/CMakeLists.txt b/strings/CMakeLists.txt
new file mode 100644
index 000000000..3c15695cc
--- /dev/null
+++ b/strings/CMakeLists.txt
@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/strings")
+
+endforeach( testsourcefile ${APP_SOURCES} )

From 7efa52e0672749b9915d8af03545f66fd6d5848e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 11:33:57 -0400
Subject: [PATCH 085/290] fix CPPLINT in sorting folder

---
 sorting/BeadSort.cpp                          |  63 ---
 sorting/BitonicSort.cpp                       |  76 ----
 sorting/Bubble Sort.cpp                       |  83 ----
 sorting/CocktailSelectionSort.cpp             | 109 -----
 sorting/NumericStringSort.cpp                 |  62 ---
 sorting/bead_sort.cpp                         |  54 +++
 sorting/bitonic_sort.cpp                      |  63 +++
 sorting/bubble_sort.cpp                       |  83 ++++
 sorting/{bucketSort.cpp => bucket_sort.cpp}   |   0
 sorting/cocktail_selection_sort.cpp           | 101 +++++
 sorting/{combsort.cpp => comb_sort.cpp}       |   0
 ...ortString.cpp => counting_sort_string.cpp} |   0
 sorting/doxy.txt                              | 374 ------------------
 ...{Insertion Sort.cpp => insertion_sort.cpp} |   0
 sorting/makefile                              |  11 -
 sorting/{Merge Sort.cpp => merge_sort.cpp}    |   0
 sorting/non_recursive_merge_sort.cpp          |  38 +-
 sorting/numeric_string_sort.cpp               |  54 +++
 .../{OddEven Sort.cpp => odd_even_sort.cpp}   |   0
 sorting/{Quick Sort.cpp => quick_sort.cpp}    |   0
 sorting/{Radix Sort.cpp => radix_sort.cpp}    |   0
 ...{Selection Sort.cpp => selection_sort.cpp} |   0
 sorting/{Shell Sort.cpp => shell_sort.cpp}    |   0
 sorting/{Slow Sort.cpp => slow_sort.cpp}      |   0
 sorting/{Tim Sort.cpp => tim_sort.cpp}        |   0
 25 files changed, 372 insertions(+), 799 deletions(-)
 delete mode 100644 sorting/BeadSort.cpp
 delete mode 100644 sorting/BitonicSort.cpp
 delete mode 100644 sorting/Bubble Sort.cpp
 delete mode 100644 sorting/CocktailSelectionSort.cpp
 delete mode 100644 sorting/NumericStringSort.cpp
 create mode 100644 sorting/bead_sort.cpp
 create mode 100644 sorting/bitonic_sort.cpp
 create mode 100644 sorting/bubble_sort.cpp
 rename sorting/{bucketSort.cpp => bucket_sort.cpp} (100%)
 create mode 100644 sorting/cocktail_selection_sort.cpp
 rename sorting/{combsort.cpp => comb_sort.cpp} (100%)
 rename sorting/{CountingSortString.cpp => counting_sort_string.cpp} (100%)
 delete mode 100644 sorting/doxy.txt
 rename sorting/{Insertion Sort.cpp => insertion_sort.cpp} (100%)
 delete mode 100644 sorting/makefile
 rename sorting/{Merge Sort.cpp => merge_sort.cpp} (100%)
 create mode 100644 sorting/numeric_string_sort.cpp
 rename sorting/{OddEven Sort.cpp => odd_even_sort.cpp} (100%)
 rename sorting/{Quick Sort.cpp => quick_sort.cpp} (100%)
 rename sorting/{Radix Sort.cpp => radix_sort.cpp} (100%)
 rename sorting/{Selection Sort.cpp => selection_sort.cpp} (100%)
 rename sorting/{Shell Sort.cpp => shell_sort.cpp} (100%)
 rename sorting/{Slow Sort.cpp => slow_sort.cpp} (100%)
 rename sorting/{Tim Sort.cpp => tim_sort.cpp} (100%)

diff --git a/sorting/BeadSort.cpp b/sorting/BeadSort.cpp
deleted file mode 100644
index c8e27b250..000000000
--- a/sorting/BeadSort.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-// C++ program to implement gravity/bead sort 
-#include <stdio.h>
-#include <string.h>
-using namespace std; 
-  
-#define BEAD(i, j) beads[i * max + j] 
-  
-// function to perform the above algorithm 
-void beadSort(int *a, int len) 
-{ 
-    // Find the maximum element 
-    int max = a[0]; 
-    for (int i = 1; i < len; i++) 
-        if (a[i] > max) 
-           max = a[i]; 
-  
-    // allocating memory 
-    unsigned char beads[max*len]; 
-    memset(beads, 0, sizeof(beads)); 
-  
-    // mark the beads 
-    for (int i = 0; i < len; i++) 
-        for (int j = 0; j < a[i]; j++) 
-            BEAD(i, j) = 1; 
-  
-    for (int j = 0; j < max; j++) 
-    { 
-        // count how many beads are on each post 
-        int sum = 0; 
-        for (int i=0; i < len; i++) 
-        { 
-            sum += BEAD(i, j); 
-            BEAD(i, j) = 0; 
-        } 
-  
-        // Move beads down 
-        for (int i = len - sum; i < len; i++) 
-            BEAD(i, j) = 1; 
-    } 
-  
-    // Put sorted values in array using beads 
-    for (int i = 0; i < len; i++) 
-    { 
-        int j; 
-        for (j = 0; j < max && BEAD(i, j); j++); 
-  
-        a[i] = j; 
-    } 
-} 
-  
-// driver function to test the algorithm 
-int main() 
-{ 
-    int a[] = {5, 3, 1, 7, 4, 1, 1, 20}; 
-    int len = sizeof(a)/sizeof(a[0]); 
-  
-    beadSort(a, len); 
-  
-    for (int i = 0; i < len; i++) 
-        printf("%d ", a[i]); 
-  
-    return 0; 
-} 
diff --git a/sorting/BitonicSort.cpp b/sorting/BitonicSort.cpp
deleted file mode 100644
index 6ad2489d2..000000000
--- a/sorting/BitonicSort.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-// Source : https://www.geeksforgeeks.org/bitonic-sort/
-
-/* C++ Program for Bitonic Sort. Note that this program 
-   works only when size of input is a power of 2. */
-
-#include <stdio.h>
-#include <algorithm.h>
-using namespace std;
-
-/*The parameter dir indicates the sorting direction, ASCENDING 
-   or DESCENDING; if (a[i] > a[j]) agrees with the direction, 
-   then a[i] and a[j] are interchanged.*/
-void compAndSwap(int a[], int i, int j, int dir)
-{
-    if (dir == (a[i] > a[j]))
-        swap(a[i], a[j]);
-}
-
-/*It recursively sorts a bitonic sequence in ascending order, 
-  if dir = 1, and in descending order otherwise (means dir=0). 
-  The sequence to be sorted starts at index position low, 
-  the parameter cnt is the number of elements to be sorted.*/
-void bitonicMerge(int a[], int low, int cnt, int dir)
-{
-    if (cnt > 1)
-    {
-        int k = cnt / 2;
-        for (int i = low; i < low + k; i++)
-            compAndSwap(a, i, i + k, dir);
-        bitonicMerge(a, low, k, dir);
-        bitonicMerge(a, low + k, k, dir);
-    }
-}
-
-/* This function first produces a bitonic sequence by recursively 
-    sorting its two halves in opposite sorting orders, and then 
-    calls bitonicMerge to make them in the same order */
-void bitonicSort(int a[], int low, int cnt, int dir)
-{
-    if (cnt > 1)
-    {
-        int k = cnt / 2;
-
-        // sort in ascending order since dir here is 1
-        bitonicSort(a, low, k, 1);
-
-        // sort in descending order since dir here is 0
-        bitonicSort(a, low + k, k, 0);
-
-        // Will merge wole sequence in ascending order
-        // since dir=1.
-        bitonicMerge(a, low, cnt, dir);
-    }
-}
-
-/* Caller of bitonicSort for sorting the entire array of 
-   length N in ASCENDING order */
-void sort(int a[], int N, int up)
-{
-    bitonicSort(a, 0, N, up);
-}
-
-// Driver code
-int main()
-{
-    int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
-    int N = sizeof(a) / sizeof(a[0]);
-
-    int up = 1; // means sort in ascending order
-    sort(a, N, up);
-
-    printf("Sorted array: \n");
-    for (int i = 0; i < N; i++)
-        printf("%d ", a[i]);
-    return 0;
-}
diff --git a/sorting/Bubble Sort.cpp b/sorting/Bubble Sort.cpp
deleted file mode 100644
index b160ac479..000000000
--- a/sorting/Bubble Sort.cpp	
+++ /dev/null
@@ -1,83 +0,0 @@
-//Bubble Sort
-
-#include <iostream>
-#include <vector>
-using namespace std;
-
-int main()
-{
-	int n;
-	short swap_check = 1;
-	cout << "Enter the amount of numbers to sort: ";
-	cin >> n;
-	vector<int> numbers;
-	cout << "Enter " << n << " numbers: ";
-	int num;
-
-	//Input
-	for (int i = 0; i < n; i++)
-	{
-		cin >> num;
-		numbers.push_back(num);
-	}
-
-	//Bubble Sorting
-	for (int i = 0; (i < n) && (swap_check == 1); i++)
-	{
-		swap_check = 0;
-		for (int j = 0; j < n - 1 - i; j++)
-		{
-			if (numbers[j] > numbers[j + 1])
-			{
-				swap_check = 1;
-				swap(numbers[j], numbers[j + 1]);// by changing swap location. I mean, j. If the number is greater than j + 1, then it means the location.
-			}
-		}
-	}
-
-	//Output
-	cout << "\nSorted Array : ";
-	for (int i = 0; i < numbers.size(); i++)
-	{
-		if (i != numbers.size() - 1)
-		{
-			cout << numbers[i] << ", ";
-		}
-		else
-		{
-			cout << numbers[i] << endl;
-		}
-	}
-	return 0;
-}
-
-/*The working principle of the Bubble sort algorithm:
-
-Bubble sort algorithm is the bubble sorting algorithm. The most important reason for calling the bubble is that the largest number is thrown at the end of this algorithm.
-This is all about the logic.
-In each iteration, the largest number is expired and when iterations are completed, the sorting takes place.
-
-What is Swap?
-
-Swap in the software means that two variables are displaced.
-An additional variable is required for this operation. x = 5, y = 10.
-We want x = 10, y = 5. Here we create the most variable to do it.
-
-int z;
-z = x;
-x = y;
-y = z;
-
-The above process is a typical displacement process.
-When x assigns the value to x, the old value of x is lost.
-That's why we created a variable z to create the first value of the value of x, and finally, we have assigned to y.
-
-Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
-
-Bubble Sort Worst Case Performance is O (n²). Why is that? Because if you remember Big O Notation, we were calculating the complexity of the algorithms in the nested loops.
-The n * (n - 1) product gives us O (n²) performance. In the worst case all the steps of the cycle will occur.
-Bubble Sort (Avarage Case) Performance. Bubble Sort is not an optimal algorithm.
-in average, O (n²) performance is taken.
-Bubble Sort Best Case Performance. O (n).
-However, you can't get the best status in the code we shared above. This happens on the optimized bubble sort algorithm. It's right down there.
-* /
diff --git a/sorting/CocktailSelectionSort.cpp b/sorting/CocktailSelectionSort.cpp
deleted file mode 100644
index cac6a3618..000000000
--- a/sorting/CocktailSelectionSort.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//Returns Sorted elements after performing Cocktail Selection Sort
-//It is a Sorting algorithm which chooses the minimum and maximum element in an array simultaneously,
-//and swaps it with the lowest and highest available position iteratively or recursively
-
-#include <iostream>
-using namespace std;
-
-//Iterative Version
-
-void CocktailSelectionSort(vector<int> &vec, int low, int high)
-{
-  while (low <= high)
-  {
-    int minimum = vec[low];
-    int minimumindex = low;
-    int maximum = vec[high];
-    int maximumindex = high;
-
-    for (int i = low; i <= high; i++)
-    {
-      if (vec[i] >= maximum)
-      {
-        maximum = vec[i];
-        maximumindex = i;
-      }
-      if (vec[i] <= minimum)
-      {
-        minimum = vec[i];
-        minimumindex = i;
-      }
-    }
-    if (low != maximumindex || high != minimumindex)
-    {
-      swap(vec[low], vec[minimumindex]);
-      swap(vec[high], vec[maximumindex]);
-    }
-    else
-    {
-      swap(vec[low], vec[high]);
-    }
-
-    low++;
-    high--;
-  }
-}
-
-//Recursive Version
-
-void CocktailSelectionSort(vector<int> &vec, int low, int high)
-{
-
-  if (low >= high)
-    return;
-
-  int minimum = vec[low];
-  int minimumindex = low;
-  int maximum = vec[high];
-  int maximumindex = high;
-
-  for (int i = low; i <= high; i++)
-  {
-    if (vec[i] >= maximum)
-    {
-      maximum = vec[i];
-      maximumindex = i;
-    }
-    if (vec[i] <= minimum)
-    {
-      minimum = vec[i];
-      minimumindex = i;
-    }
-  }
-  if (low != maximumindex || high != minimumindex)
-  {
-    swap(vec[low], vec[minimumindex]);
-    swap(vec[high], vec[maximumindex]);
-  }
-  else
-  {
-    swap(vec[low], vec[high]);
-  }
-
-  CocktailSelectionSort(vec, low + 1, high - 1);
-}
-
-//main function, select any one of iterative or recursive version
-
-int main()
-{
-
-  int n;
-  cout << "Enter number of elements\n";
-  cin >> n;
-  std::vector<int> v(n);
-  cout << "Enter all the elements\n";
-  for (int i = 0; i < n; ++i)
-  {
-    cin >> v[i];
-  }
-
-  CocktailSelectionSort(v, 0, n - 1);
-  cout << "Sorted elements are\n";
-  for (int i = 0; i < n; ++i)
-  {
-    cout << v[i] << " ";
-  }
-
-  return 0;
-}
diff --git a/sorting/NumericStringSort.cpp b/sorting/NumericStringSort.cpp
deleted file mode 100644
index 02f6964ba..000000000
--- a/sorting/NumericStringSort.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//Using general algorithms to sort a collection of strings results in alphanumeric sort.
-//If it is a numeric string, it leads to unnatural sorting
-
-//eg, an array of strings 1,10,100,2,20,200,3,30,300
-//would be sorted in that same order by using conventional sorting,
-//even though we know the correct sorting order is 1,2,3,10,20,30,100,200,300
-
-//This Programme uses a comparator to sort the array in Numerical order instead of Alphanumeric order
-
-#include <iostream>
-#include <string>
-#include <algorithm>
-using namespace std;
-
-bool NumericSort(string a, string b)
-{
-  while (a[0] == '0')
-  {
-    a.erase(a.begin());
-  }
-  while (b[0] == '0')
-  {
-    b.erase(b.begin());
-  }
-  int n = a.length();
-  int m = b.length();
-  if (n == m)
-    return a < b;
-  return n < m;
-}
-
-int main()
-{
-
-  int n;
-  cout << "Enter number of elements to be sorted Numerically\n";
-  cin >> n;
-
-  vector<string> v(n);
-  cout << "Enter the string of Numbers\n";
-  for (int i = 0; i < n; i++)
-  {
-    cin >> v[i];
-  }
-
-  sort(v.begin(), v.end());
-  cout << "Elements sorted normally \n";
-  for (int i = 0; i < n; i++)
-  {
-    cout << v[i] << " ";
-  }
-  cout << "\n";
-
-  sort(v.begin(), v.end(), NumericSort);
-  cout << "Elements sorted Numerically \n";
-  for (int i = 0; i < n; i++)
-  {
-    cout << v[i] << " ";
-  }
-
-  return 0;
-}
diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
new file mode 100644
index 000000000..12b7d4d32
--- /dev/null
+++ b/sorting/bead_sort.cpp
@@ -0,0 +1,54 @@
+// C++ program to implement gravity/bead sort
+#include <cstdio>
+#include <cstring>
+
+#define BEAD(i, j) beads[i * max + j]
+
+// function to perform the above algorithm
+void beadSort(int *a, int len) {
+    // Find the maximum element
+    int max = a[0];
+    for (int i = 1; i < len; i++)
+        if (a[i] > max) max = a[i];
+
+    // allocating memory
+    unsigned char beads[max * len];
+    memset(beads, 0, sizeof(beads));
+
+    // mark the beads
+    for (int i = 0; i < len; i++)
+        for (int j = 0; j < a[i]; j++) BEAD(i, j) = 1;
+
+    for (int j = 0; j < max; j++) {
+        // count how many beads are on each post
+        int sum = 0;
+        for (int i = 0; i < len; i++) {
+            sum += BEAD(i, j);
+            BEAD(i, j) = 0;
+        }
+
+        // Move beads down
+        for (int i = len - sum; i < len; i++) BEAD(i, j) = 1;
+    }
+
+    // Put sorted values in array using beads
+    for (int i = 0; i < len; i++) {
+        int j;
+        for (j = 0; j < max && BEAD(i, j); j++)
+            ;
+
+        a[i] = j;
+    }
+}
+
+// driver function to test the algorithm
+int main() {
+    int a[] = {5, 3, 1, 7, 4, 1, 1, 20};
+    int len = sizeof(a) / sizeof(a[0]);
+
+    beadSort(a, len);
+
+    for (int i = 0; i < len; i++) printf("%d ", a[i]);
+
+    return 0;
+}
diff --git a/sorting/bitonic_sort.cpp b/sorting/bitonic_sort.cpp
new file mode 100644
index 000000000..4d0981056
--- /dev/null
+++ b/sorting/bitonic_sort.cpp
@@ -0,0 +1,63 @@
+// Source : https://www.geeksforgeeks.org/bitonic-sort/
+
+/* C++ Program for Bitonic Sort. Note that this program
+   works only when size of input is a power of 2. */
+
+#include <algorithm>
+#include <iostream>
+
+/*The parameter dir indicates the sorting direction, ASCENDING
+   or DESCENDING; if (a[i] > a[j]) agrees with the direction,
+   then a[i] and a[j] are interchanged.*/
+void compAndSwap(int a[], int i, int j, int dir) {
+    if (dir == (a[i] > a[j])) std::swap(a[i], a[j]);
+}
+
+/*It recursively sorts a bitonic sequence in ascending order,
+  if dir = 1, and in descending order otherwise (means dir=0).
+  The sequence to be sorted starts at index position low,
+  the parameter cnt is the number of elements to be sorted.*/
+void bitonicMerge(int a[], int low, int cnt, int dir) {
+    if (cnt > 1) {
+        int k = cnt / 2;
+        for (int i = low; i < low + k; i++) compAndSwap(a, i, i + k, dir);
+        bitonicMerge(a, low, k, dir);
+        bitonicMerge(a, low + k, k, dir);
+    }
+}
+
+/* This function first produces a bitonic sequence by recursively
+    sorting its two halves in opposite sorting orders, and then
+    calls bitonicMerge to make them in the same order */
+void bitonicSort(int a[], int low, int cnt, int dir) {
+    if (cnt > 1) {
+        int k = cnt / 2;
+
+        // sort in ascending order since dir here is 1
+        bitonicSort(a, low, k, 1);
+
+        // sort in descending order since dir here is 0
+        bitonicSort(a, low + k, k, 0);
+
+        // Will merge wole sequence in ascending order
+        // since dir=1.
+        bitonicMerge(a, low, cnt, dir);
+    }
+}
+
+/* Caller of bitonicSort for sorting the entire array of
+   length N in ASCENDING order */
+void sort(int a[], int N, int up) { bitonicSort(a, 0, N, up); }
+
+// Driver code
+int main() {
+    int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
+    int N = sizeof(a) / sizeof(a[0]);
+
+    int up = 1;  // means sort in ascending order
+    sort(a, N, up);
+
+    std::cout << "Sorted array: \n";
+    for (int i = 0; i < N; i++) std::cout << a[i] << " ";
+    return 0;
+}
diff --git a/sorting/bubble_sort.cpp b/sorting/bubble_sort.cpp
new file mode 100644
index 000000000..794f65198
--- /dev/null
+++ b/sorting/bubble_sort.cpp
@@ -0,0 +1,83 @@
+/**
+ * @file
+ * @brief Bubble sort algorithm
+ *
+ * The working principle of the Bubble sort algorithm:
+
+Bubble sort algorithm is the bubble sorting algorithm. The most important reason
+for calling the bubble is that the largest number is thrown at the end of this
+algorithm. This is all about the logic. In each iteration, the largest number is
+expired and when iterations are completed, the sorting takes place.
+
+What is Swap?
+
+Swap in the software means that two variables are displaced.
+An additional variable is required for this operation. x = 5, y = 10.
+We want x = 10, y = 5. Here we create the most variable to do it.
+
+int z;
+z = x;
+x = y;
+y = z;
+
+The above process is a typical displacement process.
+When x assigns the value to x, the old value of x is lost.
+That's why we created a variable z to create the first value of the value of x,
+and finally, we have assigned to y.
+
+Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
+
+Bubble Sort Worst Case Performance is O (n²). Why is that? Because if you
+remember Big O Notation, we were calculating the complexity of the algorithms in
+the nested loops. The n * (n - 1) product gives us O (n²) performance. In the
+worst case all the steps of the cycle will occur. Bubble Sort (Avarage Case)
+Performance. Bubble Sort is not an optimal algorithm. in average, O (n²)
+performance is taken. Bubble Sort Best Case Performance. O (n). However, you
+can't get the best status in the code we shared above. This happens on the
+optimized bubble sort algorithm. It's right down there.
+*/
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    int n;
+    short swap_check = 1;
+    std::cout << "Enter the amount of numbers to sort: ";
+    std::cin >> n;
+    std::vector<int> numbers;
+    std::cout << "Enter " << n << " numbers: ";
+    int num;
+
+    // Input
+    for (int i = 0; i < n; i++) {
+        std::cin >> num;
+        numbers.push_back(num);
+    }
+
+    // Bubble Sorting
+    for (int i = 0; (i < n) && (swap_check == 1); i++) {
+        swap_check = 0;
+        for (int j = 0; j < n - 1 - i; j++) {
+            if (numbers[j] > numbers[j + 1]) {
+                swap_check = 1;
+                std::swap(numbers[j],
+                          numbers[j + 1]);  // by changing swap location.
+                                            // I mean, j. If the number is
+                                            // greater than j + 1, then it
+                                            // means the location.
+            }
+        }
+    }
+
+    // Output
+    std::cout << "\nSorted Array : ";
+    for (int i = 0; i < numbers.size(); i++) {
+        if (i != numbers.size() - 1) {
+            std::cout << numbers[i] << ", ";
+        } else {
+            std::cout << numbers[i] << std::endl;
+        }
+    }
+    return 0;
+}
diff --git a/sorting/bucketSort.cpp b/sorting/bucket_sort.cpp
similarity index 100%
rename from sorting/bucketSort.cpp
rename to sorting/bucket_sort.cpp
diff --git a/sorting/cocktail_selection_sort.cpp b/sorting/cocktail_selection_sort.cpp
new file mode 100644
index 000000000..a9abd86d5
--- /dev/null
+++ b/sorting/cocktail_selection_sort.cpp
@@ -0,0 +1,101 @@
+// Returns Sorted elements after performing Cocktail Selection Sort
+// It is a Sorting algorithm which chooses the minimum and maximum element in an
+// array simultaneously, and swaps it with the lowest and highest available
+// position iteratively or recursively
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+// Iterative Version
+
+void CocktailSelectionSort(std::vector<int> &vec, int low, int high) {
+    while (low <= high) {
+        int minimum = vec[low];
+        int minimumindex = low;
+        int maximum = vec[high];
+        int maximumindex = high;
+
+        for (int i = low; i <= high; i++) {
+            if (vec[i] >= maximum) {
+                maximum = vec[i];
+                maximumindex = i;
+            }
+            if (vec[i] <= minimum) {
+                minimum = vec[i];
+                minimumindex = i;
+            }
+        }
+        if (low != maximumindex || high != minimumindex) {
+            std::swap(vec[low], vec[minimumindex]);
+            std::swap(vec[high], vec[maximumindex]);
+        } else {
+            std::swap(vec[low], vec[high]);
+        }
+
+        low++;
+        high--;
+    }
+}
+
+// Recursive Version
+
+void CocktailSelectionSort_v2(std::vector<int> &vec, int low, int high) {
+    if (low >= high) return;
+
+    int minimum = vec[low];
+    int minimumindex = low;
+    int maximum = vec[high];
+    int maximumindex = high;
+
+    for (int i = low; i <= high; i++) {
+        if (vec[i] >= maximum) {
+            maximum = vec[i];
+            maximumindex = i;
+        }
+        if (vec[i] <= minimum) {
+            minimum = vec[i];
+            minimumindex = i;
+        }
+    }
+    if (low != maximumindex || high != minimumindex) {
+        std::swap(vec[low], vec[minimumindex]);
+        std::swap(vec[high], vec[maximumindex]);
+    } else {
+        std::swap(vec[low], vec[high]);
+    }
+
+    CocktailSelectionSort(vec, low + 1, high - 1);
+}
+
+// main function, select any one of iterative or recursive version
+
+int main() {
+    int n;
+    std::cout << "Enter number of elements\n";
+    std::cin >> n;
+    std::vector<int> v(n);
+    std::cout << "Enter all the elements\n";
+    for (int i = 0; i < n; ++i) {
+        std::cin >> v[i];
+    }
+
+    int method;
+    std::cout << "Enter method: \n\t0: iterative\n\t1: recursive:\t";
+    std::cin >> method;
+
+    if (method == 0) {
+        CocktailSelectionSort(v, 0, n - 1);
+    } else if (method == 1) {
+        CocktailSelectionSort_v2(v, 0, n - 1);
+    } else {
+        std::cerr << "Unknown method" << std::endl;
+        return -1;
+    }
+    std::cout << "Sorted elements are\n";
+    for (int i = 0; i < n; ++i) {
+        std::cout << v[i] << " ";
+    }
+
+    return 0;
+}
diff --git a/sorting/combsort.cpp b/sorting/comb_sort.cpp
similarity index 100%
rename from sorting/combsort.cpp
rename to sorting/comb_sort.cpp
diff --git a/sorting/CountingSortString.cpp b/sorting/counting_sort_string.cpp
similarity index 100%
rename from sorting/CountingSortString.cpp
rename to sorting/counting_sort_string.cpp
diff --git a/sorting/doxy.txt b/sorting/doxy.txt
deleted file mode 100644
index 68079276e..000000000
--- a/sorting/doxy.txt
+++ /dev/null
@@ -1,374 +0,0 @@
-# Doxyfile 1.8.13
-#This configuration file has been generated from Doxygen template.
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-DOXYFILE_ENCODING      = UTF-8
-PROJECT_NAME           = "My Project"
-PROJECT_NUMBER         =
-PROJECT_BRIEF          =
-PROJECT_LOGO           =
-OUTPUT_DIRECTORY       =
-CREATE_SUBDIRS         = NO
-ALLOW_UNICODE_NAMES    = NO
-OUTPUT_LANGUAGE        = English
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-ALWAYS_DETAILED_SEC    = NO
-INLINE_INHERITED_MEMB  = NO
-FULL_PATH_NAMES        = YES
-STRIP_FROM_PATH        =
-STRIP_FROM_INC_PATH    =
-SHORT_NAMES            = NO
-JAVADOC_AUTOBRIEF      = NO
-QT_AUTOBRIEF           = NO
-MULTILINE_CPP_IS_BRIEF = NO
-INHERIT_DOCS           = YES
-SEPARATE_MEMBER_PAGES  = NO
-TAB_SIZE               = 4
-ALIASES                =
-TCL_SUBST              =
-OPTIMIZE_OUTPUT_FOR_C  = NO
-OPTIMIZE_OUTPUT_JAVA   = NO
-OPTIMIZE_FOR_FORTRAN   = NO
-OPTIMIZE_OUTPUT_VHDL   = NO
-EXTENSION_MAPPING      =
-MARKDOWN_SUPPORT       = YES
-TOC_INCLUDE_HEADINGS   = 0
-AUTOLINK_SUPPORT       = YES
-BUILTIN_STL_SUPPORT    = NO
-CPP_CLI_SUPPORT        = NO
-SIP_SUPPORT            = NO
-IDL_PROPERTY_SUPPORT   = YES
-DISTRIBUTE_GROUP_DOC   = NO
-GROUP_NESTED_COMPOUNDS = NO
-SUBGROUPING            = YES
-INLINE_GROUPED_CLASSES = NO
-INLINE_SIMPLE_STRUCTS  = NO
-TYPEDEF_HIDES_STRUCT   = NO
-LOOKUP_CACHE_SIZE      = 0
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-EXTRACT_ALL            = NO
-EXTRACT_PRIVATE        = NO
-EXTRACT_PACKAGE        = NO
-EXTRACT_STATIC         = NO
-EXTRACT_LOCAL_CLASSES  = YES
-EXTRACT_LOCAL_METHODS  = NO
-EXTRACT_ANON_NSPACES   = NO
-HIDE_UNDOC_MEMBERS     = NO
-HIDE_UNDOC_CLASSES     = NO
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-INTERNAL_DOCS          = NO
-CASE_SENSE_NAMES       = YES
-HIDE_SCOPE_NAMES       = NO
-HIDE_COMPOUND_REFERENCE= NO
-SHOW_INCLUDE_FILES     = YES
-SHOW_GROUPED_MEMB_INC  = NO
-FORCE_LOCAL_INCLUDES   = NO
-INLINE_INFO            = YES
-SORT_MEMBER_DOCS       = YES
-SORT_BRIEF_DOCS        = NO
-SORT_MEMBERS_CTORS_1ST = NO
-SORT_GROUP_NAMES       = NO
-SORT_BY_SCOPE_NAME     = NO
-STRICT_PROTO_MATCHING  = NO
-GENERATE_TODOLIST      = YES
-GENERATE_TESTLIST      = YES
-GENERATE_BUGLIST       = YES
-GENERATE_DEPRECATEDLIST= YES
-ENABLED_SECTIONS       =
-MAX_INITIALIZER_LINES  = 30
-SHOW_USED_FILES        = YES
-SHOW_FILES             = YES
-SHOW_NAMESPACES        = YES
-FILE_VERSION_FILTER    =
-LAYOUT_FILE            =
-CITE_BIB_FILES         =
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET                  = NO
-WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
-WARN_IF_DOC_ERROR      = YES
-WARN_NO_PARAMDOC       = NO
-WARN_AS_ERROR          = NO
-WARN_FORMAT            = "$file:$line: $text"
-WARN_LOGFILE           =
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT                  =
-INPUT_ENCODING         = UTF-8
-FILE_PATTERNS          = *.c \
-                         *.cc \
-                         *.cxx \
-                         *.cpp \
-                         *.c++ \
-                         *.java \
-                         *.ii \
-                         *.ixx \
-                         *.ipp \
-                         *.i++ \
-                         *.inl \
-                         *.idl \
-                         *.ddl \
-                         *.odl \
-                         *.h \
-                         *.hh \
-                         *.hxx \
-                         *.hpp \
-                         *.h++ \
-                         *.cs \
-                         *.d \
-                         *.php \
-                         *.php4 \
-                         *.php5 \
-                         *.phtml \
-                         *.inc \
-                         *.m \
-                         *.markdown \
-                         *.md \
-                         *.mm \
-                         *.dox \
-                         *.py \
-                         *.pyw \
-                         *.f90 \
-                         *.f95 \
-                         *.f03 \
-                         *.f08 \
-                         *.f \
-                         *.for \
-                         *.tcl \
-                         *.vhd \
-                         *.vhdl \
-                         *.ucf \
-                         *.qsf
-RECURSIVE              = NO
-EXCLUDE                =
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       =
-EXCLUDE_SYMBOLS        =
-EXAMPLE_PATH           =
-EXAMPLE_PATTERNS       = *
-EXAMPLE_RECURSIVE      = NO
-IMAGE_PATH             =
-INPUT_FILTER           =
-FILTER_PATTERNS        =
-FILTER_SOURCE_FILES    = NO
-FILTER_SOURCE_PATTERNS =
-USE_MDFILE_AS_MAINPAGE =
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER         = NO
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = NO
-REFERENCES_RELATION    = NO
-REFERENCES_LINK_SOURCE = YES
-SOURCE_TOOLTIPS        = YES
-USE_HTAGS              = NO
-VERBATIM_HEADERS       = YES
-CLANG_ASSISTED_PARSING = NO
-CLANG_OPTIONS          =
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
-COLS_IN_ALPHA_INDEX    = 5
-IGNORE_PREFIX          =
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML          = YES
-HTML_OUTPUT            = html
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            =
-HTML_FOOTER            =
-HTML_STYLESHEET        =
-HTML_EXTRA_STYLESHEET  =
-HTML_EXTRA_FILES       =
-HTML_COLORSTYLE_HUE    = 220
-HTML_COLORSTYLE_SAT    = 100
-HTML_COLORSTYLE_GAMMA  = 80
-HTML_TIMESTAMP         = NO
-HTML_DYNAMIC_SECTIONS  = NO
-HTML_INDEX_NUM_ENTRIES = 100
-GENERATE_DOCSET        = NO
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-DOCSET_PUBLISHER_NAME  = Publisher
-GENERATE_HTMLHELP      = NO
-CHM_FILE               =
-HHC_LOCATION           =
-GENERATE_CHI           = NO
-CHM_INDEX_ENCODING     =
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-GENERATE_QHP           = NO
-QCH_FILE               =
-QHP_NAMESPACE          = org.doxygen.Project
-QHP_VIRTUAL_FOLDER     = doc
-QHP_CUST_FILTER_NAME   =
-QHP_CUST_FILTER_ATTRS  =
-QHP_SECT_FILTER_ATTRS  =
-QHG_LOCATION           =
-GENERATE_ECLIPSEHELP   = NO
-ECLIPSE_DOC_ID         = org.doxygen.Project
-DISABLE_INDEX          = NO
-GENERATE_TREEVIEW      = NO
-ENUM_VALUES_PER_LINE   = 4
-TREEVIEW_WIDTH         = 250
-EXT_LINKS_IN_WINDOW    = NO
-FORMULA_FONTSIZE       = 10
-FORMULA_TRANSPARENT    = YES
-USE_MATHJAX            = NO
-MATHJAX_FORMAT         = HTML-CSS
-MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
-MATHJAX_EXTENSIONS     =
-MATHJAX_CODEFILE       =
-SEARCHENGINE           = YES
-SERVER_BASED_SEARCH    = NO
-EXTERNAL_SEARCH        = NO
-SEARCHENGINE_URL       =
-SEARCHDATA_FILE        = searchdata.xml
-EXTERNAL_SEARCH_ID     =
-EXTRA_SEARCH_MAPPINGS  =
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX         = NO
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         = latex
-MAKEINDEX_CMD_NAME     = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4
-EXTRA_PACKAGES         =
-LATEX_HEADER           =
-LATEX_FOOTER           =
-LATEX_EXTRA_STYLESHEET =
-LATEX_EXTRA_FILES      =
-PDF_HYPERLINKS         = YES
-USE_PDFLATEX           = YES
-LATEX_BATCHMODE        = NO
-LATEX_HIDE_INDICES     = NO
-LATEX_SOURCE_CODE      = NO
-LATEX_BIB_STYLE        = plain
-LATEX_TIMESTAMP        = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = NO
-RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    =
-RTF_EXTENSIONS_FILE    =
-RTF_SOURCE_CODE        = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_SUBDIR             =
-MAN_LINKS              = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML           = NO
-XML_OUTPUT             = xml
-XML_PROGRAMLISTING     = YES
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-GENERATE_DOCBOOK       = NO
-DOCBOOK_OUTPUT         = docbook
-DOCBOOK_PROGRAMLISTING = NO
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF   = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX =
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING   = YES
-MACRO_EXPANSION        = NO
-EXPAND_ONLY_PREDEF     = NO
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           =
-INCLUDE_FILE_PATTERNS  =
-PREDEFINED             =
-EXPAND_AS_DEFINED      =
-SKIP_FUNCTION_MACROS   = YES
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-TAGFILES               =
-GENERATE_TAGFILE       =
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-EXTERNAL_PAGES         = YES
-PERL_PATH              = /usr/bin/perl
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-CLASS_DIAGRAMS         = YES
-MSCGEN_PATH            =
-DIA_PATH               =
-HIDE_UNDOC_RELATIONS   = YES
-HAVE_DOT               = YES
-DOT_NUM_THREADS        = 0
-DOT_FONTNAME           = Helvetica
-DOT_FONTSIZE           = 10
-DOT_FONTPATH           =
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = YES
-GROUP_GRAPHS           = YES
-UML_LOOK               = NO
-UML_LIMIT_NUM_FIELDS   = 10
-TEMPLATE_RELATIONS     = NO
-INCLUDE_GRAPH          = YES
-INCLUDED_BY_GRAPH      = YES
-CALL_GRAPH             = NO
-CALLER_GRAPH           = NO
-GRAPHICAL_HIERARCHY    = YES
-DIRECTORY_GRAPH        = YES
-DOT_IMAGE_FORMAT       = png
-INTERACTIVE_SVG        = NO
-DOT_PATH               =
-DOTFILE_DIRS           =
-MSCFILE_DIRS           =
-DIAFILE_DIRS           =
-PLANTUML_JAR_PATH      =
-PLANTUML_CFG_FILE      =
-PLANTUML_INCLUDE_PATH  =
-DOT_GRAPH_MAX_NODES    = 50
-MAX_DOT_GRAPH_DEPTH    = 0
-DOT_TRANSPARENT        = NO
-DOT_MULTI_TARGETS      = NO
-GENERATE_LEGEND        = YES
-DOT_CLEANUP            = YES
diff --git a/sorting/Insertion Sort.cpp b/sorting/insertion_sort.cpp
similarity index 100%
rename from sorting/Insertion Sort.cpp
rename to sorting/insertion_sort.cpp
diff --git a/sorting/makefile b/sorting/makefile
deleted file mode 100644
index 21d3186c6..000000000
--- a/sorting/makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-non_recursive_merge_sort: non_recursive_merge_sort.cpp
-	g++ -std=c++17 -o non_recursive_merge_sort non_recursive_merge_sort.cpp
-.PHONY: test
-.PHONY: doc
-.PHONY: clean
-test: non_recursive_merge_sort
-	./non_recursive_merge_sort
-doc: doxy.txt
-	doxygen doxy.txt
-clean:
-	rm -fr non_recursive_merge_sort html
diff --git a/sorting/Merge Sort.cpp b/sorting/merge_sort.cpp
similarity index 100%
rename from sorting/Merge Sort.cpp
rename to sorting/merge_sort.cpp
diff --git a/sorting/non_recursive_merge_sort.cpp b/sorting/non_recursive_merge_sort.cpp
index c6ca56376..ebfef1dcc 100644
--- a/sorting/non_recursive_merge_sort.cpp
+++ b/sorting/non_recursive_merge_sort.cpp
@@ -6,7 +6,7 @@
  */
 #include <cstddef>  // for size_t
 #include <utility>  // for std::move & std::remove_reference_t
-template<class Iterator>
+template <class Iterator>
 void merge(Iterator, Iterator, const Iterator, char[]);
 /// bottom-up merge sort which sorts elements in a non-decreasing order
 /**
@@ -17,13 +17,13 @@ void merge(Iterator, Iterator, const Iterator, char[]);
  * @param first points to the first element
  * @param last points to 1-step past the last element
  * @param n the number of elements
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const Iterator last,
                               const size_t n) {
     // create a buffer large enough to store all elements
     // dynamically allocated to comply with cpplint
-    char * buffer = new char[n * sizeof(*first)];
+    char* buffer = new char[n * sizeof(*first)];
     // buffer size can be optimized to largest power of 2 less than n elements
     // divide the container into equally-sized segments whose length start at 1
     // and keeps increasing by factors of 2
@@ -49,32 +49,28 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
  * @param r points to the right part, end of left part
  * @param e points to end of right part
  * @param b points at the buffer
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
     // create 2 pointers to point at the buffer
     auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
     // move the left part of the segment
-    for (Iterator t(l); r != t; ++t)
-        *p++ = std::move(*t);
+    for (Iterator t(l); r != t; ++t) *p++ = std::move(*t);
     // while neither the buffer nor the right part has been exhausted
     // move the smallest element of the two back to the container
-    while (e != r && c != p)
-        *l++ = std::move(*r < *c ? *r++ : *c++);
+    while (e != r && c != p) *l++ = std::move(*r < *c ? *r++ : *c++);
     // notice only one of the two following loops will be executed
     // while the right part hasn't bee exhausted, move it back
-    while (e != r)
-        *l++ = std::move(*r++);
+    while (e != r) *l++ = std::move(*r++);
     // while the buffer hasn't bee exhausted, move it back
-    while (c != p)
-        *l++ = std::move(*c++);
+    while (c != p) *l++ = std::move(*c++);
 }
 /// bottom-up merge sort which sorts elements in a non-decreasing order
 /**
  * @param first points to the first element
  * @param n the number of elements
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const size_t n) {
     non_recursive_merge_sort(first, first + n, n);
 }
@@ -82,8 +78,8 @@ void non_recursive_merge_sort(const Iterator first, const size_t n) {
 /**
  * @param first points to the first element
  * @param last points to 1-step past the last element
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const Iterator last) {
     non_recursive_merge_sort(first, last, last - first);
 }
@@ -92,15 +88,15 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last) {
  * Currently, it only creates output for non_recursive_merge_sort.cpp, but if
  * it has proven its efficacy it can be expanded to other files.
  * The configuration file is named doxy.txt and has been auto-generated too.
-*/
+ */
 // the remaining of this file is only for testing. It can erased to to convert
 // it into a header file for later re-use.
 #include <iostream>
-int main(int argc, char ** argv) {
+int main(int argc, char** argv) {
     int size;
     std::cout << "Enter the number of elements : ";
     std::cin >> size;
-    int * arr = new int[size];
+    int* arr = new int[size];
     for (int i = 0; i < size; ++i) {
         std::cout << "arr[" << i << "] = ";
         std::cin >> arr[i];
diff --git a/sorting/numeric_string_sort.cpp b/sorting/numeric_string_sort.cpp
new file mode 100644
index 000000000..8b86bb29d
--- /dev/null
+++ b/sorting/numeric_string_sort.cpp
@@ -0,0 +1,54 @@
+// Using general algorithms to sort a collection of strings results in
+// alphanumeric sort. If it is a numeric string, it leads to unnatural sorting
+
+// eg, an array of strings 1,10,100,2,20,200,3,30,300
+// would be sorted in that same order by using conventional sorting,
+// even though we know the correct sorting order is 1,2,3,10,20,30,100,200,300
+
+// This Programme uses a comparator to sort the array in Numerical order instead
+// of Alphanumeric order
+
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>
+
+bool NumericSort(std::string a, std::string b) {
+    while (a[0] == '0') {
+        a.erase(a.begin());
+    }
+    while (b[0] == '0') {
+        b.erase(b.begin());
+    }
+    int n = a.length();
+    int m = b.length();
+    if (n == m) return a < b;
+    return n < m;
+}
+
+int main() {
+    int n;
+    std::cout << "Enter number of elements to be sorted Numerically\n";
+    std::cin >> n;
+
+    std::vector<std::string> v(n);
+    std::cout << "Enter the string of Numbers\n";
+    for (int i = 0; i < n; i++) {
+        std::cin >> v[i];
+    }
+
+    sort(v.begin(), v.end());
+    std::cout << "Elements sorted normally \n";
+    for (int i = 0; i < n; i++) {
+        std::cout << v[i] << " ";
+    }
+    std::cout << "\n";
+
+    std::sort(v.begin(), v.end(), NumericSort);
+    std::cout << "Elements sorted Numerically \n";
+    for (int i = 0; i < n; i++) {
+        std::cout << v[i] << " ";
+    }
+
+    return 0;
+}
diff --git a/sorting/OddEven Sort.cpp b/sorting/odd_even_sort.cpp
similarity index 100%
rename from sorting/OddEven Sort.cpp
rename to sorting/odd_even_sort.cpp
diff --git a/sorting/Quick Sort.cpp b/sorting/quick_sort.cpp
similarity index 100%
rename from sorting/Quick Sort.cpp
rename to sorting/quick_sort.cpp
diff --git a/sorting/Radix Sort.cpp b/sorting/radix_sort.cpp
similarity index 100%
rename from sorting/Radix Sort.cpp
rename to sorting/radix_sort.cpp
diff --git a/sorting/Selection Sort.cpp b/sorting/selection_sort.cpp
similarity index 100%
rename from sorting/Selection Sort.cpp
rename to sorting/selection_sort.cpp
diff --git a/sorting/Shell Sort.cpp b/sorting/shell_sort.cpp
similarity index 100%
rename from sorting/Shell Sort.cpp
rename to sorting/shell_sort.cpp
diff --git a/sorting/Slow Sort.cpp b/sorting/slow_sort.cpp
similarity index 100%
rename from sorting/Slow Sort.cpp
rename to sorting/slow_sort.cpp
diff --git a/sorting/Tim Sort.cpp b/sorting/tim_sort.cpp
similarity index 100%
rename from sorting/Tim Sort.cpp
rename to sorting/tim_sort.cpp

From b35a7875dacda7643df506968349f8841328551e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 11:34:07 -0400
Subject: [PATCH 086/290] add CMAKE to sorting folder

---
 CMakeLists.txt         |  1 +
 sorting/CMakeLists.txt | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+)
 create mode 100644 sorting/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ab633b827..f2940c962 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -51,6 +51,7 @@ endif()
 add_subdirectory(math)
 add_subdirectory(others)
 add_subdirectory(strings)
+add_subdirectory(sorting)
 add_subdirectory(computer_oriented_statistical_methods)
 
 if(USE_OPENMP)
diff --git a/sorting/CMakeLists.txt b/sorting/CMakeLists.txt
new file mode 100644
index 000000000..9e76c8dec
--- /dev/null
+++ b/sorting/CMakeLists.txt
@@ -0,0 +1,20 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES
+        LINKER_LANGUAGE CXX
+        CXX_STANDARD 14)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/strings")
+
+endforeach( testsourcefile ${APP_SOURCES} )

From 0941caf209b9b6ddbf8f1278bd809f02d4801905 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 15:34:31 +0000
Subject: [PATCH 087/290] updating DIRECTORY.md

---
 DIRECTORY.md | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 47842b9ca..9a336c1a5 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -179,29 +179,29 @@
   * [Ternary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/ternary_search.cpp)
 
 ## Sorting
-  * [Beadsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/BeadSort.cpp)
-  * [Bitonicsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/BitonicSort.cpp)
-  * [Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Bubble%20Sort.cpp)
-  * [Bucketsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bucketSort.cpp)
-  * [Cocktailselectionsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/CocktailSelectionSort.cpp)
-  * [Combsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/combsort.cpp)
+  * [Bead Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bead_sort.cpp)
+  * [Bitonic Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bitonic_sort.cpp)
+  * [Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bubble_sort.cpp)
+  * [Bucket Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bucket_sort.cpp)
+  * [Cocktail Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/cocktail_selection_sort.cpp)
+  * [Comb Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/comb_sort.cpp)
   * [Counting Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Counting_Sort.cpp)
-  * [Countingsortstring](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/CountingSortString.cpp)
+  * [Counting Sort String](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/counting_sort_string.cpp)
   * [Heap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/heap_sort.cpp)
-  * [Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Insertion%20Sort.cpp)
+  * [Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/insertion_sort.cpp)
   * [Library Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/library_sort.cpp)
-  * [Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Merge%20Sort.cpp)
+  * [Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/merge_sort.cpp)
   * [Non Recursive Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/non_recursive_merge_sort.cpp)
-  * [Numericstringsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/NumericStringSort.cpp)
-  * [Oddeven Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/OddEven%20Sort.cpp)
-  * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Quick%20Sort.cpp)
-  * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Radix%20Sort.cpp)
-  * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Selection%20Sort.cpp)
-  * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Shell%20Sort.cpp)
+  * [Numeric String Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/numeric_string_sort.cpp)
+  * [Odd Even Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/odd_even_sort.cpp)
+  * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort.cpp)
+  * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort.cpp)
+  * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort.cpp)
+  * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort.cpp)
   * [Shell Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort2.cpp)
-  * [Slow Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Slow%20Sort.cpp)
+  * [Slow Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/slow_sort.cpp)
   * [Swap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/swap_sort.cpp)
-  * [Tim Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Tim%20Sort.cpp)
+  * [Tim Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/tim_sort.cpp)
 
 ## Strings
   * [Brute Force String Searching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/strings/brute_force_string_searching.cpp)

From 47cc3f6825733ae974044684e21f686bff74291c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 11:37:04 -0400
Subject: [PATCH 088/290] fix sorting bin output foldername

---
 sorting/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sorting/CMakeLists.txt b/sorting/CMakeLists.txt
index 9e76c8dec..00877bb61 100644
--- a/sorting/CMakeLists.txt
+++ b/sorting/CMakeLists.txt
@@ -15,6 +15,6 @@ foreach( testsourcefile ${APP_SOURCES} )
     if(OpenMP_CXX_FOUND)
         target_link_libraries(${testname} OpenMP::OpenMP_CXX)
     endif()
-    install(TARGETS ${testname} DESTINATION "bin/strings")
+    install(TARGETS ${testname} DESTINATION "bin/sorting")
 
 endforeach( testsourcefile ${APP_SOURCES} )

From 76a5f572d5d9834585201836183027e3575b1e55 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 11:46:24 -0400
Subject: [PATCH 089/290] sorting fixes for MSVC and CPPLINT

---
 sorting/bead_sort.cpp   |  5 ++--
 sorting/bucket_sort.cpp | 51 ++++++++++++++++++-----------------------
 sorting/comb_sort.cpp   | 47 +++++++++++++++----------------------
 3 files changed, 43 insertions(+), 60 deletions(-)

diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
index 12b7d4d32..d34706073 100644
--- a/sorting/bead_sort.cpp
+++ b/sorting/bead_sort.cpp
@@ -12,8 +12,8 @@ void beadSort(int *a, int len) {
         if (a[i] > max) max = a[i];
 
     // allocating memory
-    unsigned char beads[max * len];
-    memset(beads, 0, sizeof(beads));
+    unsigned char *beads = new unsigned char[max * len];
+    memset(beads, 0, max * len);
 
     // mark the beads
     for (int i = 0; i < len; i++)
@@ -39,6 +39,7 @@ void beadSort(int *a, int len) {
 
         a[i] = j;
     }
+    delete[] beads;
 }
 
 // driver function to test the algorithm
diff --git a/sorting/bucket_sort.cpp b/sorting/bucket_sort.cpp
index 0ffbf8e4c..f120f04fc 100644
--- a/sorting/bucket_sort.cpp
+++ b/sorting/bucket_sort.cpp
@@ -1,42 +1,35 @@
 // C++ program to sort an array using bucket sort
-#include <iostream>
 #include <algorithm>
+#include <iostream>
 #include <vector>
-using namespace std;
 
 // Function to sort arr[] of size n using bucket sort
-void bucketSort(float arr[], int n)
-{
-   // 1) Create n empty buckets
-   vector<float> b[n];
+void bucketSort(float arr[], int n) {
+    // 1) Create n empty buckets
+    std::vector<float> b[n];
 
-   // 2) Put array elements in different buckets
-   for (int i = 0; i < n; i++)
-   {
-      int bi = n * arr[i]; // Index in bucket
-      b[bi].push_back(arr[i]);
-   }
+    // 2) Put array elements in different buckets
+    for (int i = 0; i < n; i++) {
+        int bi = n * arr[i];  // Index in bucket
+        b[bi].push_back(arr[i]);
+    }
 
-   // 3) Sort individual buckets
-   for (int i = 0; i < n; i++)
-      sort(b[i].begin(), b[i].end());
+    // 3) Sort individual buckets
+    for (int i = 0; i < n; i++) std::sort(b[i].begin(), b[i].end());
 
-   // 4) Concatenate all buckets into arr[]
-   int index = 0;
-   for (int i = 0; i < n; i++)
-      for (int j = 0; j < b[i].size(); j++)
-         arr[index++] = b[i][j];
+    // 4) Concatenate all buckets into arr[]
+    int index = 0;
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < b[i].size(); j++) arr[index++] = b[i][j];
 }
 
 /* Driver program to test above funtion */
-int main()
-{
-   float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
-   int n = sizeof(arr) / sizeof(arr[0]);
-   bucketSort(arr, n);
+int main() {
+    float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    bucketSort(arr, n);
 
-   cout << "Sorted array is \n";
-   for (int i = 0; i < n; i++)
-      cout << arr[i] << " ";
-   return 0;
+    std::cout << "Sorted array is \n";
+    for (int i = 0; i < n; i++) std::cout << arr[i] << " ";
+    return 0;
 }
diff --git a/sorting/comb_sort.cpp b/sorting/comb_sort.cpp
index 2209c96fc..feed4ba44 100644
--- a/sorting/comb_sort.cpp
+++ b/sorting/comb_sort.cpp
@@ -1,59 +1,48 @@
-//Kind of better version of Bubble sort.
-//While Bubble sort is comparering adjacent value, Combsort is using gap larger than 1
-//Best case: O(n)
-//Worst case: O(n ^ 2)
+// Kind of better version of Bubble sort.
+// While Bubble sort is comparering adjacent value, Combsort is using gap larger
+// than 1 Best case: O(n) Worst case: O(n ^ 2)
 
 #include <iostream>
 
-using namespace std;
-
 int a[100005];
 int n;
 
-int FindNextGap(int x)
-{
+int FindNextGap(int x) {
     x = (x * 10) / 13;
 
-    return max(1, x);
+    return std::max(1, x);
 }
 
-void CombSort(int a[], int l, int r)
-{
-    //Init gap
+void CombSort(int a[], int l, int r) {
+    // Init gap
     int gap = n;
 
-    //Initialize swapped as true to make sure that loop runs
+    // Initialize swapped as true to make sure that loop runs
     bool swapped = true;
 
-    //Keep running until gap = 1 or none elements were swapped
-    while (gap != 1 || swapped)
-    {
-        //Find next gap
+    // Keep running until gap = 1 or none elements were swapped
+    while (gap != 1 || swapped) {
+        // Find next gap
         gap = FindNextGap(gap);
 
         swapped = false;
 
         // Compare all elements with current gap
-        for (int i = l; i <= r - gap; ++i)
-        {
-            if (a[i] > a[i + gap])
-            {
-                swap(a[i], a[i + gap]);
+        for (int i = l; i <= r - gap; ++i) {
+            if (a[i] > a[i + gap]) {
+                std::swap(a[i], a[i + gap]);
                 swapped = true;
             }
         }
     }
 }
 
-int main()
-{
-    cin >> n;
-    for (int i = 1; i <= n; ++i)
-        cin >> a[i];
+int main() {
+    std::cin >> n;
+    for (int i = 1; i <= n; ++i) std::cin >> a[i];
 
     CombSort(a, 1, n);
 
-    for (int i = 1; i <= n; ++i)
-        cout << a[i] << ' ';
+    for (int i = 1; i <= n; ++i) std::cout << a[i] << ' ';
     return 0;
 }

From 0d8e015d15b87ea188b75f1f70b7be614cdf86cd Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 12:15:12 -0400
Subject: [PATCH 090/290] cpplint and msvc fixes for - sorting

---
 sorting/bead_sort.cpp               |  4 +--
 sorting/bubble_sort.cpp             |  8 +++---
 sorting/cocktail_selection_sort.cpp | 44 ++++++++++++++---------------
 3 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
index d34706073..a1a54c1e0 100644
--- a/sorting/bead_sort.cpp
+++ b/sorting/bead_sort.cpp
@@ -34,8 +34,8 @@ void beadSort(int *a, int len) {
     // Put sorted values in array using beads
     for (int i = 0; i < len; i++) {
         int j;
-        for (j = 0; j < max && BEAD(i, j); j++)
-            ;
+        for (j = 0; j < max && BEAD(i, j); j++) {
+        }
 
         a[i] = j;
     }
diff --git a/sorting/bubble_sort.cpp b/sorting/bubble_sort.cpp
index 794f65198..c43e425fc 100644
--- a/sorting/bubble_sort.cpp
+++ b/sorting/bubble_sort.cpp
@@ -42,7 +42,7 @@ optimized bubble sort algorithm. It's right down there.
 
 int main() {
     int n;
-    short swap_check = 1;
+    bool swap_check = true;
     std::cout << "Enter the amount of numbers to sort: ";
     std::cin >> n;
     std::vector<int> numbers;
@@ -56,11 +56,11 @@ int main() {
     }
 
     // Bubble Sorting
-    for (int i = 0; (i < n) && (swap_check == 1); i++) {
-        swap_check = 0;
+    for (int i = 0; (i < n) && (swap_check); i++) {
+        swap_check = false;
         for (int j = 0; j < n - 1 - i; j++) {
             if (numbers[j] > numbers[j + 1]) {
-                swap_check = 1;
+                swap_check = true;
                 std::swap(numbers[j],
                           numbers[j + 1]);  // by changing swap location.
                                             // I mean, j. If the number is
diff --git a/sorting/cocktail_selection_sort.cpp b/sorting/cocktail_selection_sort.cpp
index a9abd86d5..ab6229996 100644
--- a/sorting/cocktail_selection_sort.cpp
+++ b/sorting/cocktail_selection_sort.cpp
@@ -9,28 +9,28 @@
 
 // Iterative Version
 
-void CocktailSelectionSort(std::vector<int> &vec, int low, int high) {
+void CocktailSelectionSort(std::vector<int> *vec, int low, int high) {
     while (low <= high) {
-        int minimum = vec[low];
+        int minimum = (*vec)[low];
         int minimumindex = low;
-        int maximum = vec[high];
+        int maximum = (*vec)[high];
         int maximumindex = high;
 
         for (int i = low; i <= high; i++) {
-            if (vec[i] >= maximum) {
-                maximum = vec[i];
+            if ((*vec)[i] >= maximum) {
+                maximum = (*vec)[i];
                 maximumindex = i;
             }
-            if (vec[i] <= minimum) {
-                minimum = vec[i];
+            if ((*vec)[i] <= minimum) {
+                minimum = (*vec)[i];
                 minimumindex = i;
             }
         }
         if (low != maximumindex || high != minimumindex) {
-            std::swap(vec[low], vec[minimumindex]);
-            std::swap(vec[high], vec[maximumindex]);
+            std::swap((*vec)[low], (*vec)[minimumindex]);
+            std::swap((*vec)[high], (*vec)[maximumindex]);
         } else {
-            std::swap(vec[low], vec[high]);
+            std::swap((*vec)[low], (*vec)[high]);
         }
 
         low++;
@@ -40,29 +40,29 @@ void CocktailSelectionSort(std::vector<int> &vec, int low, int high) {
 
 // Recursive Version
 
-void CocktailSelectionSort_v2(std::vector<int> &vec, int low, int high) {
+void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high) {
     if (low >= high) return;
 
-    int minimum = vec[low];
+    int minimum = (*vec)[low];
     int minimumindex = low;
-    int maximum = vec[high];
+    int maximum = (*vec)[high];
     int maximumindex = high;
 
     for (int i = low; i <= high; i++) {
-        if (vec[i] >= maximum) {
-            maximum = vec[i];
+        if ((*vec)[i] >= maximum) {
+            maximum = (*vec)[i];
             maximumindex = i;
         }
-        if (vec[i] <= minimum) {
-            minimum = vec[i];
+        if ((*vec)[i] <= minimum) {
+            minimum = (*vec)[i];
             minimumindex = i;
         }
     }
     if (low != maximumindex || high != minimumindex) {
-        std::swap(vec[low], vec[minimumindex]);
-        std::swap(vec[high], vec[maximumindex]);
+        std::swap((*vec)[low], (*vec)[minimumindex]);
+        std::swap((*vec)[high], (*vec)[maximumindex]);
     } else {
-        std::swap(vec[low], vec[high]);
+        std::swap((*vec)[low], (*vec)[high]);
     }
 
     CocktailSelectionSort(vec, low + 1, high - 1);
@@ -85,9 +85,9 @@ int main() {
     std::cin >> method;
 
     if (method == 0) {
-        CocktailSelectionSort(v, 0, n - 1);
+        CocktailSelectionSort(&v, 0, n - 1);
     } else if (method == 1) {
-        CocktailSelectionSort_v2(v, 0, n - 1);
+        CocktailSelectionSort_v2(&v, 0, n - 1);
     } else {
         std::cerr << "Unknown method" << std::endl;
         return -1;

From 717f5c8f01c1d5559320e118ccc8eabdf602e8ff Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 12:31:49 -0400
Subject: [PATCH 091/290] fix dynamic array

---
 sorting/bucket_sort.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sorting/bucket_sort.cpp b/sorting/bucket_sort.cpp
index f120f04fc..c43865281 100644
--- a/sorting/bucket_sort.cpp
+++ b/sorting/bucket_sort.cpp
@@ -6,7 +6,7 @@
 // Function to sort arr[] of size n using bucket sort
 void bucketSort(float arr[], int n) {
     // 1) Create n empty buckets
-    std::vector<float> b[n];
+    std::vector<float> *b = new std::vector<float>[n];
 
     // 2) Put array elements in different buckets
     for (int i = 0; i < n; i++) {
@@ -21,6 +21,7 @@ void bucketSort(float arr[], int n) {
     int index = 0;
     for (int i = 0; i < n; i++)
         for (int j = 0; j < b[i].size(); j++) arr[index++] = b[i][j];
+    delete[] b;
 }
 
 /* Driver program to test above funtion */

From 01b69fcb249c30d4f1795766bf4cc617d8200ab3 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:02:10 -0400
Subject: [PATCH 092/290] fix dynamic array issues in sorting folder

---
 sorting/comb_sort.cpp      |   1 +
 sorting/insertion_sort.cpp |  62 ++++++++++----------
 sorting/merge_sort.cpp     |  66 +++++++++------------
 sorting/quick_sort.cpp     |  51 +++++++---------
 sorting/radix_sort.cpp     | 116 +++++++++++++++++--------------------
 sorting/shell_sort.cpp     |  72 ++++++++++-------------
 sorting/slow_sort.cpp      |  82 +++++++++++++-------------
 sorting/swap_sort.cpp      |   7 ++-
 sorting/tim_sort.cpp       | 110 ++++++++++++++++-------------------
 9 files changed, 256 insertions(+), 311 deletions(-)

diff --git a/sorting/comb_sort.cpp b/sorting/comb_sort.cpp
index feed4ba44..1b0a4d706 100644
--- a/sorting/comb_sort.cpp
+++ b/sorting/comb_sort.cpp
@@ -2,6 +2,7 @@
 // While Bubble sort is comparering adjacent value, Combsort is using gap larger
 // than 1 Best case: O(n) Worst case: O(n ^ 2)
 
+#include <algorithm>
 #include <iostream>
 
 int a[100005];
diff --git a/sorting/insertion_sort.cpp b/sorting/insertion_sort.cpp
index 2563acaf8..fe920ca59 100644
--- a/sorting/insertion_sort.cpp
+++ b/sorting/insertion_sort.cpp
@@ -1,40 +1,36 @@
-//Insertion Sort
+// Insertion Sort
 
 #include <iostream>
-using namespace std;
 
-int main()
-{
-	int n;
-	cout << "\nEnter the length of your array : ";
-	cin >> n;
-	int Array[n];
-	cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
+int main() {
+    int n;
+    std::cout << "\nEnter the length of your array : ";
+    std::cin >> n;
+    int *Array = new int[n];
+    std::cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
 
-	//Input
-	for (int i = 0; i < n; i++)
-	{
-		cin >> Array[i];
-	}
+    // Input
+    for (int i = 0; i < n; i++) {
+        std::cin >> Array[i];
+    }
 
-	//Sorting
-	for (int i = 1; i < n; i++)
-	{
-		int temp = Array[i];
-		int j = i - 1;
-		while (j >= 0 && temp < Array[j])
-		{
-			Array[j + 1] = Array[j];
-			j--;
-		}
-		Array[j + 1] = temp;
-	}
+    // Sorting
+    for (int i = 1; i < n; i++) {
+        int temp = Array[i];
+        int j = i - 1;
+        while (j >= 0 && temp < Array[j]) {
+            Array[j + 1] = Array[j];
+            j--;
+        }
+        Array[j + 1] = temp;
+    }
 
-	//Output
-	cout << "\nSorted Array : ";
-	for (int i = 0; i < n; i++)
-	{
-		cout << Array[i] << "\t";
-	}
-	return 0;
+    // Output
+    std::cout << "\nSorted Array : ";
+    for (int i = 0; i < n; i++) {
+        std::cout << Array[i] << "\t";
+    }
+
+    delete[] Array;
+    return 0;
 }
diff --git a/sorting/merge_sort.cpp b/sorting/merge_sort.cpp
index b8edc8851..82ab869cd 100644
--- a/sorting/merge_sort.cpp
+++ b/sorting/merge_sort.cpp
@@ -1,57 +1,47 @@
 #include <iostream>
-using namespace std;
 
-void merge(int arr[], int l, int m, int r)
-{
+void merge(int arr[], int l, int m, int r) {
     int i, j, k;
     int n1 = m - l + 1;
     int n2 = r - m;
 
-    int L[n1], R[n2];
+    int *L = new int[n1], *R = new int[n2];
 
-    for (i = 0; i < n1; i++)
-        L[i] = arr[l + i];
-    for (j = 0; j < n2; j++)
-        R[j] = arr[m + 1 + j];
+    for (i = 0; i < n1; i++) L[i] = arr[l + i];
+    for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
 
     i = 0;
     j = 0;
     k = l;
-    while (i < n1 && j < n2)
-    {
-        if (L[i] <= R[j])
-        {
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) {
             arr[k] = L[i];
             i++;
-        }
-        else
-        {
+        } else {
             arr[k] = R[j];
             j++;
         }
         k++;
     }
 
-    while (i < n1)
-    {
+    while (i < n1) {
         arr[k] = L[i];
         i++;
         k++;
     }
 
-    while (j < n2)
-    {
+    while (j < n2) {
         arr[k] = R[j];
         j++;
         k++;
     }
+
+    delete[] L;
+    delete[] R;
 }
 
-void mergeSort(int arr[], int l, int r)
-{
-    if (l < r)
-    {
-
+void mergeSort(int arr[], int l, int r) {
+    if (l < r) {
         int m = l + (r - l) / 2;
 
         mergeSort(arr, l, m);
@@ -61,33 +51,31 @@ void mergeSort(int arr[], int l, int r)
     }
 }
 
-void show(int A[], int size)
-{
+void show(int A[], int size) {
     int i;
-    for (i = 0; i < size; i++)
-        cout << A[i] << "\n";
+    for (i = 0; i < size; i++) std::cout << A[i] << "\n";
 }
 
-int main()
-{
+int main() {
     int size;
-    cout << "\nEnter the number of elements : ";
+    std::cout << "\nEnter the number of elements : ";
 
-    cin >> size;
+    std::cin >> size;
 
-    int arr[size];
+    int *arr = new int[size];
 
-    cout << "\nEnter the unsorted elements : ";
+    std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i)
-    {
-        cout << "\n";
-        cin >> arr[i];
+    for (int i = 0; i < size; ++i) {
+        std::cout << "\n";
+        std::cin >> arr[i];
     }
 
     mergeSort(arr, 0, size);
 
-    cout << "Sorted array\n";
+    std::cout << "Sorted array\n";
     show(arr, size);
+
+    delete[] arr;
     return 0;
 }
diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
index 0b807898f..489e10965 100644
--- a/sorting/quick_sort.cpp
+++ b/sorting/quick_sort.cpp
@@ -1,19 +1,15 @@
 /* C implementation QuickSort */
 #include <iostream>
-using namespace std;
 
-int partition(int arr[], int low, int high)
-{
-    int pivot = arr[high]; // pivot
-    int i = (low - 1);     // Index of smaller element
+int partition(int arr[], int low, int high) {
+    int pivot = arr[high];  // pivot
+    int i = (low - 1);      // Index of smaller element
 
-    for (int j = low; j < high; j++)
-    {
+    for (int j = low; j < high; j++) {
         // If current element is smaller than or
         // equal to pivot
-        if (arr[j] <= pivot)
-        {
-            i++; // increment index of smaller element
+        if (arr[j] <= pivot) {
+            i++;  // increment index of smaller element
             int temp = arr[i];
             arr[i] = arr[j];
             arr[j] = temp;
@@ -25,11 +21,8 @@ int partition(int arr[], int low, int high)
     return (i + 1);
 }
 
-void quickSort(int arr[], int low, int high)
-{
-    if (low < high)
-    {
-
+void quickSort(int arr[], int low, int high) {
+    if (low < high) {
         int p = partition(arr, low, high);
 
         quickSort(arr, low, p - 1);
@@ -37,31 +30,29 @@ void quickSort(int arr[], int low, int high)
     }
 }
 
-void show(int arr[], int size)
-{
-    for (int i = 0; i < size; i++)
-        cout << arr[i] << "\n";
+void show(int arr[], int size) {
+    for (int i = 0; i < size; i++) std::cout << arr[i] << "\n";
 }
 
 // Driver program to test above functions
-int main()
-{
+int main() {
     int size;
-    cout << "\nEnter the number of elements : ";
+    std::cout << "\nEnter the number of elements : ";
 
-    cin >> size;
+    std::cin >> size;
 
-    int arr[size];
+    int *arr = new int[size];
 
-    cout << "\nEnter the unsorted elements : ";
+    std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i)
-    {
-        cout << "\n";
-        cin >> arr[i];
+    for (int i = 0; i < size; ++i) {
+        std::cout << "\n";
+        std::cin >> arr[i];
     }
     quickSort(arr, 0, size);
-    cout << "Sorted array\n";
+    std::cout << "Sorted array\n";
     show(arr, size);
+
+    delete[] arr;
     return 0;
 }
diff --git a/sorting/radix_sort.cpp b/sorting/radix_sort.cpp
index 09c91bb22..e5bc3db84 100644
--- a/sorting/radix_sort.cpp
+++ b/sorting/radix_sort.cpp
@@ -1,68 +1,58 @@
-#include <iostream>
-#include <cstdlib>
 #include <cmath>
+#include <cstdlib>
 #include <cstring>
-using namespace std;
-void radixsort(int a[], int n)
-{
-	int count[10];
-	int output[n];
-	memset(output, 0, sizeof(output));
-	memset(count, 0, sizeof(count));
-	int max = 0;
-	for (int i = 0; i < n; ++i)
-	{
-		if (a[i] > max)
-		{
-			max = a[i];
-		}
-	}
-	int maxdigits = 0;
-	while (max)
-	{
-		maxdigits++;
-		max /= 10;
-	}
-	for (int j = 0; j < maxdigits; j++)
-	{
-		for (int i = 0; i < n; i++)
-		{
-			int t = pow(10, j);
-			count[(a[i] % (10 * t)) / t]++;
-		}
-		int k = 0;
-		for (int p = 0; p < 10; p++)
-		{
-			for (int i = 0; i < n; i++)
-			{
-				int t = pow(10, j);
-				if ((a[i] % (10 * t)) / t == p)
-				{
-					output[k] = a[i];
-					k++;
-				}
-			}
-		}
-		memset(count, 0, sizeof(count));
-		for (int i = 0; i < n; ++i)
-		{
-			a[i] = output[i];
-		}
-	}
+#include <iostream>
+
+void radixsort(int a[], int n) {
+    int count[10];
+    int* output = new int[n];
+    memset(output, 0, n * sizeof(*output));
+    memset(count, 0, sizeof(count));
+    int max = 0;
+    for (int i = 0; i < n; ++i) {
+        if (a[i] > max) {
+            max = a[i];
+        }
+    }
+    int maxdigits = 0;
+    while (max) {
+        maxdigits++;
+        max /= 10;
+    }
+    for (int j = 0; j < maxdigits; j++) {
+        for (int i = 0; i < n; i++) {
+            int t = std::pow(10, j);
+            count[(a[i] % (10 * t)) / t]++;
+        }
+        int k = 0;
+        for (int p = 0; p < 10; p++) {
+            for (int i = 0; i < n; i++) {
+                int t = std::pow(10, j);
+                if ((a[i] % (10 * t)) / t == p) {
+                    output[k] = a[i];
+                    k++;
+                }
+            }
+        }
+        memset(count, 0, sizeof(count));
+        for (int i = 0; i < n; ++i) {
+            a[i] = output[i];
+        }
+    }
+    delete[] output;
 }
-void print(int a[], int n)
-{
-	for (int i = 0; i < n; ++i)
-	{
-		cout << a[i] << " ";
-	}
-	cout << endl;
+
+void print(int a[], int n) {
+    for (int i = 0; i < n; ++i) {
+        std::cout << a[i] << " ";
+    }
+    std::cout << std::endl;
 }
-int main(int argc, char const *argv[])
-{
-	int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
-	int n = sizeof(a) / sizeof(a[0]);
-	radixsort(a, n);
-	print(a, n);
-	return 0;
+
+int main(int argc, char const* argv[]) {
+    int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
+    int n = sizeof(a) / sizeof(a[0]);
+    radixsort(a, n);
+    print(a, n);
+    return 0;
 }
\ No newline at end of file
diff --git a/sorting/shell_sort.cpp b/sorting/shell_sort.cpp
index b08c7ffd8..eb701478d 100644
--- a/sorting/shell_sort.cpp
+++ b/sorting/shell_sort.cpp
@@ -1,45 +1,37 @@
 #include <iostream>
-using namespace std;
 
-int main()
-{
-	int size = 10;
-	int array[size];
-	// Input
-	cout << "\nHow many numbers do want to enter in unsorted array : ";
-	cin >> size;
-	cout << "\nEnter the numbers for unsorted array : ";
-	for (int i = 0; i < size; i++)
-	{
-		cin >> array[i];
-	}
+int main() {
+    int size = 10;
+    int* array = new int[size];
+    // Input
+    std::cout << "\nHow many numbers do want to enter in unsorted array : ";
+    std::cin >> size;
+    std::cout << "\nEnter the numbers for unsorted array : ";
+    for (int i = 0; i < size; i++) {
+        std::cin >> array[i];
+    }
 
-	// Sorting
-	for (int i = size / 2; i > 0; i = i / 2)
-	{
-		for (int j = i; j < size; j++)
-		{
-			for (int k = j - i; k >= 0; k = k - i)
-			{
-				if (array[k] < array[k + i])
-				{
-					break;
-				}
-				else
-				{
-					int temp = array[k + i];
-					array[k + i] = array[k];
-					array[k] = temp;
-				}
-			}
-		}
-	}
+    // Sorting
+    for (int i = size / 2; i > 0; i = i / 2) {
+        for (int j = i; j < size; j++) {
+            for (int k = j - i; k >= 0; k = k - i) {
+                if (array[k] < array[k + i]) {
+                    break;
+                } else {
+                    int temp = array[k + i];
+                    array[k + i] = array[k];
+                    array[k] = temp;
+                }
+            }
+        }
+    }
 
-	// Output
-	cout << "\nSorted array : ";
-	for (int i = 0; i < size; ++i)
-	{
-		cout << array[i] << "\t";
-	}
-	return 0;
+    // Output
+    std::cout << "\nSorted array : ";
+    for (int i = 0; i < size; ++i) {
+        std::cout << array[i] << "\t";
+    }
+
+    delete[] array;
+    return 0;
 }
diff --git a/sorting/slow_sort.cpp b/sorting/slow_sort.cpp
index f8f7e74b8..2872b37d8 100644
--- a/sorting/slow_sort.cpp
+++ b/sorting/slow_sort.cpp
@@ -1,57 +1,55 @@
-//Returns the sorted vector after performing SlowSort
-//It is a sorting algorithm that is of humorous nature and not useful.
-//It's based on the principle of multiply and surrender, a tongue-in-cheek joke of divide and conquer.
-//It was published in 1986 by Andrei Broder and Jorge Stolfi in their paper Pessimal Algorithms and Simplexity Analysis.
-//This algorithm multiplies a single problem into multiple subproblems
-//It is interesting because it is provably the least efficient sorting algorithm that can be built asymptotically,
-//and with the restriction that such an algorithm, while being slow, must still all the time be working towards a result.
+// Returns the sorted vector after performing SlowSort
+// It is a sorting algorithm that is of humorous nature and not useful.
+// It's based on the principle of multiply and surrender, a tongue-in-cheek joke
+// of divide and conquer. It was published in 1986 by Andrei Broder and Jorge
+// Stolfi in their paper Pessimal Algorithms and Simplexity Analysis. This
+// algorithm multiplies a single problem into multiple subproblems It is
+// interesting because it is provably the least efficient sorting algorithm that
+// can be built asymptotically, and with the restriction that such an algorithm,
+// while being slow, must still all the time be working towards a result.
 
 #include <iostream>
 using namespace std;
 
-void SlowSort(int a[], int i, int j)
-{
-  if (i >= j)
-    return;
-  int m = i + (j - i) / 2; //midpoint, implemented this way to avoid overflow
-  int temp;
-  SlowSort(a, i, m);
-  SlowSort(a, m + 1, j);
-  if (a[j] < a[m])
-  {
-    temp = a[j]; //swapping a[j] & a[m]
-    a[j] = a[m];
-    a[m] = temp;
-  }
-  SlowSort(a, i, j - 1);
+void SlowSort(int a[], int i, int j) {
+    if (i >= j) return;
+    int m = i + (j - i) / 2;  // midpoint, implemented this way to avoid
+                              // overflow
+    int temp;
+    SlowSort(a, i, m);
+    SlowSort(a, m + 1, j);
+    if (a[j] < a[m]) {
+        temp = a[j];  // swapping a[j] & a[m]
+        a[j] = a[m];
+        a[m] = temp;
+    }
+    SlowSort(a, i, j - 1);
 }
 
-//Sample Main function
+// Sample Main function
 
-int main()
-{
-  int size;
-  cout << "\nEnter the number of elements : ";
+int main() {
+    int size;
+    cout << "\nEnter the number of elements : ";
 
-  cin >> size;
+    cin >> size;
 
-  int arr[size];
+    int *arr = new int[size];
 
-  cout << "\nEnter the unsorted elements : ";
+    cout << "\nEnter the unsorted elements : ";
 
-  for (int i = 0; i < size; ++i)
-  {
-    cout << "\n";
-    cin >> arr[i];
-  }
+    for (int i = 0; i < size; ++i) {
+        cout << "\n";
+        cin >> arr[i];
+    }
 
-  SlowSort(arr, 0, size);
+    SlowSort(arr, 0, size);
 
-  cout << "Sorted array\n";
+    cout << "Sorted array\n";
 
-  for (int i = 0; i < size; ++i)
-  {
-    cout << arr[i] << " ";
-  }
-  return 0;
+    for (int i = 0; i < size; ++i) {
+        cout << arr[i] << " ";
+    }
+    delete[] arr;
+    return 0;
 }
diff --git a/sorting/swap_sort.cpp b/sorting/swap_sort.cpp
index a4ab1e57b..2e59e2fb3 100644
--- a/sorting/swap_sort.cpp
+++ b/sorting/swap_sort.cpp
@@ -10,7 +10,7 @@ int minSwaps(int arr[], int n) {
     // Create an array of pairs where first
     // element is array element and second element
     // is position of first element
-    std::pair<int, int> arrPos[n];
+    std::pair<int, int> *arrPos = new std::pair<int, int>[n];
     for (int i = 0; i < n; i++) {
         arrPos[i].first = arr[i];
         arrPos[i].second = i;
@@ -32,8 +32,7 @@ int minSwaps(int arr[], int n) {
     for (int i = 0; i < n; i++) {
         // already swapped and corrected or
         // already present at correct pos
-        if (vis[i] || arrPos[i].second == i)
-            continue;
+        if (vis[i] || arrPos[i].second == i) continue;
 
         // find out the number of node in
         // this cycle and add in ans
@@ -53,6 +52,8 @@ int minSwaps(int arr[], int n) {
         }
     }
 
+    delete[] arrPos;
+
     // Return result
     return ans;
 }
diff --git a/sorting/tim_sort.cpp b/sorting/tim_sort.cpp
index 14d3a04d0..94f5aa230 100644
--- a/sorting/tim_sort.cpp
+++ b/sorting/tim_sort.cpp
@@ -1,115 +1,103 @@
 // C++ program to perform TimSort.
+#include <algorithm>
 #include <iostream>
-using namespace std;
+
 const int RUN = 32;
- 
-// this function sorts array from left index to to right index which is of size atmost RUN
-void insertionSort(int arr[], int left, int right)
-{
-    for (int i = left + 1; i <= right; i++)
-    {
+
+// this function sorts array from left index to to right index which is of size
+// atmost RUN
+void insertionSort(int arr[], int left, int right) {
+    for (int i = left + 1; i <= right; i++) {
         int temp = arr[i];
         int j = i - 1;
-        while (arr[j] > temp && j >= left)
-        {
-            arr[j+1] = arr[j];
+        while (arr[j] > temp && j >= left) {
+            arr[j + 1] = arr[j];
             j--;
         }
-        arr[j+1] = temp;
+        arr[j + 1] = temp;
     }
 }
- 
+
 // merge function merges the sorted runs
-void merge(int arr[], int l, int m, int r)
-{
+void merge(int arr[], int l, int m, int r) {
     // original array is broken in two parts, left and right array
     int len1 = m - l + 1, len2 = r - m;
-    int left[len1], right[len2];
-    for (int i = 0; i < len1; i++)
-        left[i] = arr[l + i];
-    for (int i = 0; i < len2; i++)
-        right[i] = arr[m + 1 + i];
- 
+    int *left = new int[len1], *right = new int[len2];
+    for (int i = 0; i < len1; i++) left[i] = arr[l + i];
+    for (int i = 0; i < len2; i++) right[i] = arr[m + 1 + i];
+
     int i = 0;
     int j = 0;
     int k = l;
- 
+
     // after comparing, we merge those two array in larger sub array
-    while (i < len1 && j < len2)
-    {
-        if (left[i] <= right[j])
-        {
+    while (i < len1 && j < len2) {
+        if (left[i] <= right[j]) {
             arr[k] = left[i];
             i++;
-        }
-        else
-        {
+        } else {
             arr[k] = right[j];
             j++;
         }
         k++;
     }
- 
+
     // copy remaining elements of left, if any
-    while (i < len1)
-    {
+    while (i < len1) {
         arr[k] = left[i];
         k++;
         i++;
     }
- 
+
     // copy remaining element of right, if any
-    while (j < len2)
-    {
+    while (j < len2) {
         arr[k] = right[j];
         k++;
         j++;
     }
+    delete[] left;
+    delete[] right;
 }
- 
+
 // iterative Timsort function to sort the array[0...n-1] (similar to merge sort)
-void timSort(int arr[], int n)
-{
+void timSort(int arr[], int n) {
     // Sort individual subarrays of size RUN
-    for (int i = 0; i < n; i+=RUN)
-        insertionSort(arr, i, min((i+31), (n-1)));
- 
-    // start merging from size RUN (or 32). It will merge to form size 64, then 128, 256 and so on ....
-    for (int size = RUN; size < n; size = 2*size)
-    {
-        // pick starting point of left sub array. We are going to merge arr[left..left+size-1] and arr[left+size, left+2*size-1]
-        // After every merge, we increase left by 2*size
-        for (int left = 0; left < n; left += 2*size)
-        {
+    for (int i = 0; i < n; i += RUN)
+        insertionSort(arr, i, std::min((i + 31), (n - 1)));
+
+    // start merging from size RUN (or 32). It will merge to form size 64, then
+    // 128, 256 and so on ....
+    for (int size = RUN; size < n; size = 2 * size) {
+        // pick starting point of left sub array. We are going to merge
+        // arr[left..left+size-1] and arr[left+size, left+2*size-1] After every
+        // merge, we increase left by 2*size
+        for (int left = 0; left < n; left += 2 * size) {
             // find ending point of left sub array
             // mid+1 is starting point of right sub array
             int mid = left + size - 1;
-            int right = min((left + 2*size - 1), (n-1));
- 
+            int right = std::min((left + 2 * size - 1), (n - 1));
+
             // merge sub array arr[left.....mid] & arr[mid+1....right]
             merge(arr, left, mid, right);
         }
     }
 }
- 
+
 // utility function to print the Array
-void printArray(int arr[], int n)
-{
-    for (int i = 0; i < n; i++)
-        printf("%d  ", arr[i]);
-    printf("\n");
+void printArray(int arr[], int n) {
+    for (int i = 0; i < n; i++) printf("%d  ", arr[i]);
+    std::cout << std::endl;
 }
- 
+
 // Driver program to test above function
-int main()
-{
+int main() {
     int arr[] = {5, 21, 7, 23, 19};
-    int n = sizeof(arr)/sizeof(arr[0]);
+    int n = sizeof(arr) / sizeof(arr[0]);
     printf("Given Array is\n");
     printArray(arr, n);
- 
+
     timSort(arr, n);
- 
+
     printf("After Sorting Array is\n");
     printArray(arr, n);
     return 0;

From 35c53760d34bc483ba737706937985346bf39fd8 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:07:14 -0400
Subject: [PATCH 093/290] cpplint issues fixed in sorting folder

---
 sorting/radix_sort.cpp |  2 +-
 sorting/slow_sort.cpp  | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/sorting/radix_sort.cpp b/sorting/radix_sort.cpp
index e5bc3db84..a0fbfe99e 100644
--- a/sorting/radix_sort.cpp
+++ b/sorting/radix_sort.cpp
@@ -55,4 +55,4 @@ int main(int argc, char const* argv[]) {
     radixsort(a, n);
     print(a, n);
     return 0;
-}
\ No newline at end of file
+}
diff --git a/sorting/slow_sort.cpp b/sorting/slow_sort.cpp
index 2872b37d8..b2627d12f 100644
--- a/sorting/slow_sort.cpp
+++ b/sorting/slow_sort.cpp
@@ -9,7 +9,6 @@
 // while being slow, must still all the time be working towards a result.
 
 #include <iostream>
-using namespace std;
 
 void SlowSort(int a[], int i, int j) {
     if (i >= j) return;
@@ -30,26 +29,27 @@ void SlowSort(int a[], int i, int j) {
 
 int main() {
     int size;
-    cout << "\nEnter the number of elements : ";
+    std::cout << "\nEnter the number of elements : ";
 
-    cin >> size;
+    std::cin >> size;
 
     int *arr = new int[size];
 
-    cout << "\nEnter the unsorted elements : ";
+    std::cout << "\nEnter the unsorted elements : ";
 
     for (int i = 0; i < size; ++i) {
-        cout << "\n";
-        cin >> arr[i];
+        std::cout << "\n";
+        std::cin >> arr[i];
     }
 
     SlowSort(arr, 0, size);
 
-    cout << "Sorted array\n";
+    std::cout << "Sorted array\n";
 
     for (int i = 0; i < size; ++i) {
-        cout << arr[i] << " ";
+        std::cout << arr[i] << " ";
     }
+
     delete[] arr;
     return 0;
 }

From 7e3d87695f7341ab60059ce8988310fa06249b06 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:07:30 -0400
Subject: [PATCH 094/290] remove redundant github action

---
 .../sorting_non_recursive_merge_sort.yml      | 24 -------------------
 1 file changed, 24 deletions(-)
 delete mode 100644 .github/workflows/sorting_non_recursive_merge_sort.yml

diff --git a/.github/workflows/sorting_non_recursive_merge_sort.yml b/.github/workflows/sorting_non_recursive_merge_sort.yml
deleted file mode 100644
index add9efd5d..000000000
--- a/.github/workflows/sorting_non_recursive_merge_sort.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-name: sorting_non_recursive_merge_sort
-on:
-  pull_request:
-  push:
-  #  branches: [master]
-jobs:
-  sorting_non_recursive_merge_sort:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-      - uses: mattnotmitt/doxygen-action@master
-        with:
-          working-directory: 'sorting/'
-          doxyfile-path: 'doxy.txt'
-      #- uses: peaceiris/actions-gh-pages@v3
-      #  with:
-      #    github_token: ${{ secrets.GITHUB_TOKEN }}
-      #    publish_dir: ./sorting
-      #    external_repository: TheAlgorithms/C-Plus-Plus
-      #    publish_branch: master
-      #    enable_jekyll: true
-      - run: |
-          cd sorting
-          make test

From 966aa2d333123fa124f52d02fc2f3d37261fe923 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:28:12 -0400
Subject: [PATCH 095/290] remove mainpage doxygen tag

---
 sorting/non_recursive_merge_sort.cpp | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/sorting/non_recursive_merge_sort.cpp b/sorting/non_recursive_merge_sort.cpp
index ebfef1dcc..9d4e95f2f 100644
--- a/sorting/non_recursive_merge_sort.cpp
+++ b/sorting/non_recursive_merge_sort.cpp
@@ -5,7 +5,9 @@
  * A generic implementation of non-recursive merge sort.
  */
 #include <cstddef>  // for size_t
+#include <iostream>
 #include <utility>  // for std::move & std::remove_reference_t
+
 template <class Iterator>
 void merge(Iterator, Iterator, const Iterator, char[]);
 /// bottom-up merge sort which sorts elements in a non-decreasing order
@@ -83,15 +85,7 @@ template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const Iterator last) {
     non_recursive_merge_sort(first, last, last - first);
 }
-/**
- * @mainpage A demonstration of auto-generated documentation using Doxygen.
- * Currently, it only creates output for non_recursive_merge_sort.cpp, but if
- * it has proven its efficacy it can be expanded to other files.
- * The configuration file is named doxy.txt and has been auto-generated too.
- */
-// the remaining of this file is only for testing. It can erased to to convert
-// it into a header file for later re-use.
-#include <iostream>
+
 int main(int argc, char** argv) {
     int size;
     std::cout << "Enter the number of elements : ";

From a2e7d9099944588e3e0ab5ce04ec40ac13991982 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:28:33 -0400
Subject: [PATCH 096/290] add mainpage tag to README in the root folder

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e8034d7c4..4befc6afa 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# The Algorithms - C++ 
+# The Algorithms - C++ # {#mainpage}
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
 ![GitHub repo size](https://img.shields.io/github/repo-size/TheAlgorithms/C-Plus-Plus?color=red&style=flat-square)
 ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/TheAlgorithms/C-Plus-Plus?color=green&style=flat-square)

From e4084e77a81a4124ad58b294cc2618cb917ec59e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 11:33:57 -0400
Subject: [PATCH 097/290] fix CPPLINT in sorting folder

(cherry picked from commit 7efa52e0672749b9915d8af03545f66fd6d5848e)
---
 sorting/BeadSort.cpp                          |  63 ---
 sorting/BitonicSort.cpp                       |  76 ----
 sorting/Bubble Sort.cpp                       |  83 ----
 sorting/CocktailSelectionSort.cpp             | 109 -----
 sorting/NumericStringSort.cpp                 |  62 ---
 sorting/bead_sort.cpp                         |  54 +++
 sorting/bitonic_sort.cpp                      |  63 +++
 sorting/bubble_sort.cpp                       |  83 ++++
 sorting/{bucketSort.cpp => bucket_sort.cpp}   |   0
 sorting/cocktail_selection_sort.cpp           | 101 +++++
 sorting/{combsort.cpp => comb_sort.cpp}       |   0
 ...ortString.cpp => counting_sort_string.cpp} |   0
 sorting/doxy.txt                              | 374 ------------------
 ...{Insertion Sort.cpp => insertion_sort.cpp} |   0
 sorting/makefile                              |  11 -
 sorting/{Merge Sort.cpp => merge_sort.cpp}    |   0
 sorting/non_recursive_merge_sort.cpp          |  38 +-
 sorting/numeric_string_sort.cpp               |  54 +++
 .../{OddEven Sort.cpp => odd_even_sort.cpp}   |   0
 sorting/{Quick Sort.cpp => quick_sort.cpp}    |   0
 sorting/{Radix Sort.cpp => radix_sort.cpp}    |   0
 ...{Selection Sort.cpp => selection_sort.cpp} |   0
 sorting/{Shell Sort.cpp => shell_sort.cpp}    |   0
 sorting/{Slow Sort.cpp => slow_sort.cpp}      |   0
 sorting/{Tim Sort.cpp => tim_sort.cpp}        |   0
 25 files changed, 372 insertions(+), 799 deletions(-)
 delete mode 100644 sorting/BeadSort.cpp
 delete mode 100644 sorting/BitonicSort.cpp
 delete mode 100644 sorting/Bubble Sort.cpp
 delete mode 100644 sorting/CocktailSelectionSort.cpp
 delete mode 100644 sorting/NumericStringSort.cpp
 create mode 100644 sorting/bead_sort.cpp
 create mode 100644 sorting/bitonic_sort.cpp
 create mode 100644 sorting/bubble_sort.cpp
 rename sorting/{bucketSort.cpp => bucket_sort.cpp} (100%)
 create mode 100644 sorting/cocktail_selection_sort.cpp
 rename sorting/{combsort.cpp => comb_sort.cpp} (100%)
 rename sorting/{CountingSortString.cpp => counting_sort_string.cpp} (100%)
 delete mode 100644 sorting/doxy.txt
 rename sorting/{Insertion Sort.cpp => insertion_sort.cpp} (100%)
 delete mode 100644 sorting/makefile
 rename sorting/{Merge Sort.cpp => merge_sort.cpp} (100%)
 create mode 100644 sorting/numeric_string_sort.cpp
 rename sorting/{OddEven Sort.cpp => odd_even_sort.cpp} (100%)
 rename sorting/{Quick Sort.cpp => quick_sort.cpp} (100%)
 rename sorting/{Radix Sort.cpp => radix_sort.cpp} (100%)
 rename sorting/{Selection Sort.cpp => selection_sort.cpp} (100%)
 rename sorting/{Shell Sort.cpp => shell_sort.cpp} (100%)
 rename sorting/{Slow Sort.cpp => slow_sort.cpp} (100%)
 rename sorting/{Tim Sort.cpp => tim_sort.cpp} (100%)

diff --git a/sorting/BeadSort.cpp b/sorting/BeadSort.cpp
deleted file mode 100644
index c8e27b250..000000000
--- a/sorting/BeadSort.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-// C++ program to implement gravity/bead sort 
-#include <stdio.h>
-#include <string.h>
-using namespace std; 
-  
-#define BEAD(i, j) beads[i * max + j] 
-  
-// function to perform the above algorithm 
-void beadSort(int *a, int len) 
-{ 
-    // Find the maximum element 
-    int max = a[0]; 
-    for (int i = 1; i < len; i++) 
-        if (a[i] > max) 
-           max = a[i]; 
-  
-    // allocating memory 
-    unsigned char beads[max*len]; 
-    memset(beads, 0, sizeof(beads)); 
-  
-    // mark the beads 
-    for (int i = 0; i < len; i++) 
-        for (int j = 0; j < a[i]; j++) 
-            BEAD(i, j) = 1; 
-  
-    for (int j = 0; j < max; j++) 
-    { 
-        // count how many beads are on each post 
-        int sum = 0; 
-        for (int i=0; i < len; i++) 
-        { 
-            sum += BEAD(i, j); 
-            BEAD(i, j) = 0; 
-        } 
-  
-        // Move beads down 
-        for (int i = len - sum; i < len; i++) 
-            BEAD(i, j) = 1; 
-    } 
-  
-    // Put sorted values in array using beads 
-    for (int i = 0; i < len; i++) 
-    { 
-        int j; 
-        for (j = 0; j < max && BEAD(i, j); j++); 
-  
-        a[i] = j; 
-    } 
-} 
-  
-// driver function to test the algorithm 
-int main() 
-{ 
-    int a[] = {5, 3, 1, 7, 4, 1, 1, 20}; 
-    int len = sizeof(a)/sizeof(a[0]); 
-  
-    beadSort(a, len); 
-  
-    for (int i = 0; i < len; i++) 
-        printf("%d ", a[i]); 
-  
-    return 0; 
-} 
diff --git a/sorting/BitonicSort.cpp b/sorting/BitonicSort.cpp
deleted file mode 100644
index 6ad2489d2..000000000
--- a/sorting/BitonicSort.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-// Source : https://www.geeksforgeeks.org/bitonic-sort/
-
-/* C++ Program for Bitonic Sort. Note that this program 
-   works only when size of input is a power of 2. */
-
-#include <stdio.h>
-#include <algorithm.h>
-using namespace std;
-
-/*The parameter dir indicates the sorting direction, ASCENDING 
-   or DESCENDING; if (a[i] > a[j]) agrees with the direction, 
-   then a[i] and a[j] are interchanged.*/
-void compAndSwap(int a[], int i, int j, int dir)
-{
-    if (dir == (a[i] > a[j]))
-        swap(a[i], a[j]);
-}
-
-/*It recursively sorts a bitonic sequence in ascending order, 
-  if dir = 1, and in descending order otherwise (means dir=0). 
-  The sequence to be sorted starts at index position low, 
-  the parameter cnt is the number of elements to be sorted.*/
-void bitonicMerge(int a[], int low, int cnt, int dir)
-{
-    if (cnt > 1)
-    {
-        int k = cnt / 2;
-        for (int i = low; i < low + k; i++)
-            compAndSwap(a, i, i + k, dir);
-        bitonicMerge(a, low, k, dir);
-        bitonicMerge(a, low + k, k, dir);
-    }
-}
-
-/* This function first produces a bitonic sequence by recursively 
-    sorting its two halves in opposite sorting orders, and then 
-    calls bitonicMerge to make them in the same order */
-void bitonicSort(int a[], int low, int cnt, int dir)
-{
-    if (cnt > 1)
-    {
-        int k = cnt / 2;
-
-        // sort in ascending order since dir here is 1
-        bitonicSort(a, low, k, 1);
-
-        // sort in descending order since dir here is 0
-        bitonicSort(a, low + k, k, 0);
-
-        // Will merge wole sequence in ascending order
-        // since dir=1.
-        bitonicMerge(a, low, cnt, dir);
-    }
-}
-
-/* Caller of bitonicSort for sorting the entire array of 
-   length N in ASCENDING order */
-void sort(int a[], int N, int up)
-{
-    bitonicSort(a, 0, N, up);
-}
-
-// Driver code
-int main()
-{
-    int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
-    int N = sizeof(a) / sizeof(a[0]);
-
-    int up = 1; // means sort in ascending order
-    sort(a, N, up);
-
-    printf("Sorted array: \n");
-    for (int i = 0; i < N; i++)
-        printf("%d ", a[i]);
-    return 0;
-}
diff --git a/sorting/Bubble Sort.cpp b/sorting/Bubble Sort.cpp
deleted file mode 100644
index b160ac479..000000000
--- a/sorting/Bubble Sort.cpp	
+++ /dev/null
@@ -1,83 +0,0 @@
-//Bubble Sort
-
-#include <iostream>
-#include <vector>
-using namespace std;
-
-int main()
-{
-	int n;
-	short swap_check = 1;
-	cout << "Enter the amount of numbers to sort: ";
-	cin >> n;
-	vector<int> numbers;
-	cout << "Enter " << n << " numbers: ";
-	int num;
-
-	//Input
-	for (int i = 0; i < n; i++)
-	{
-		cin >> num;
-		numbers.push_back(num);
-	}
-
-	//Bubble Sorting
-	for (int i = 0; (i < n) && (swap_check == 1); i++)
-	{
-		swap_check = 0;
-		for (int j = 0; j < n - 1 - i; j++)
-		{
-			if (numbers[j] > numbers[j + 1])
-			{
-				swap_check = 1;
-				swap(numbers[j], numbers[j + 1]);// by changing swap location. I mean, j. If the number is greater than j + 1, then it means the location.
-			}
-		}
-	}
-
-	//Output
-	cout << "\nSorted Array : ";
-	for (int i = 0; i < numbers.size(); i++)
-	{
-		if (i != numbers.size() - 1)
-		{
-			cout << numbers[i] << ", ";
-		}
-		else
-		{
-			cout << numbers[i] << endl;
-		}
-	}
-	return 0;
-}
-
-/*The working principle of the Bubble sort algorithm:
-
-Bubble sort algorithm is the bubble sorting algorithm. The most important reason for calling the bubble is that the largest number is thrown at the end of this algorithm.
-This is all about the logic.
-In each iteration, the largest number is expired and when iterations are completed, the sorting takes place.
-
-What is Swap?
-
-Swap in the software means that two variables are displaced.
-An additional variable is required for this operation. x = 5, y = 10.
-We want x = 10, y = 5. Here we create the most variable to do it.
-
-int z;
-z = x;
-x = y;
-y = z;
-
-The above process is a typical displacement process.
-When x assigns the value to x, the old value of x is lost.
-That's why we created a variable z to create the first value of the value of x, and finally, we have assigned to y.
-
-Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
-
-Bubble Sort Worst Case Performance is O (n²). Why is that? Because if you remember Big O Notation, we were calculating the complexity of the algorithms in the nested loops.
-The n * (n - 1) product gives us O (n²) performance. In the worst case all the steps of the cycle will occur.
-Bubble Sort (Avarage Case) Performance. Bubble Sort is not an optimal algorithm.
-in average, O (n²) performance is taken.
-Bubble Sort Best Case Performance. O (n).
-However, you can't get the best status in the code we shared above. This happens on the optimized bubble sort algorithm. It's right down there.
-* /
diff --git a/sorting/CocktailSelectionSort.cpp b/sorting/CocktailSelectionSort.cpp
deleted file mode 100644
index cac6a3618..000000000
--- a/sorting/CocktailSelectionSort.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//Returns Sorted elements after performing Cocktail Selection Sort
-//It is a Sorting algorithm which chooses the minimum and maximum element in an array simultaneously,
-//and swaps it with the lowest and highest available position iteratively or recursively
-
-#include <iostream>
-using namespace std;
-
-//Iterative Version
-
-void CocktailSelectionSort(vector<int> &vec, int low, int high)
-{
-  while (low <= high)
-  {
-    int minimum = vec[low];
-    int minimumindex = low;
-    int maximum = vec[high];
-    int maximumindex = high;
-
-    for (int i = low; i <= high; i++)
-    {
-      if (vec[i] >= maximum)
-      {
-        maximum = vec[i];
-        maximumindex = i;
-      }
-      if (vec[i] <= minimum)
-      {
-        minimum = vec[i];
-        minimumindex = i;
-      }
-    }
-    if (low != maximumindex || high != minimumindex)
-    {
-      swap(vec[low], vec[minimumindex]);
-      swap(vec[high], vec[maximumindex]);
-    }
-    else
-    {
-      swap(vec[low], vec[high]);
-    }
-
-    low++;
-    high--;
-  }
-}
-
-//Recursive Version
-
-void CocktailSelectionSort(vector<int> &vec, int low, int high)
-{
-
-  if (low >= high)
-    return;
-
-  int minimum = vec[low];
-  int minimumindex = low;
-  int maximum = vec[high];
-  int maximumindex = high;
-
-  for (int i = low; i <= high; i++)
-  {
-    if (vec[i] >= maximum)
-    {
-      maximum = vec[i];
-      maximumindex = i;
-    }
-    if (vec[i] <= minimum)
-    {
-      minimum = vec[i];
-      minimumindex = i;
-    }
-  }
-  if (low != maximumindex || high != minimumindex)
-  {
-    swap(vec[low], vec[minimumindex]);
-    swap(vec[high], vec[maximumindex]);
-  }
-  else
-  {
-    swap(vec[low], vec[high]);
-  }
-
-  CocktailSelectionSort(vec, low + 1, high - 1);
-}
-
-//main function, select any one of iterative or recursive version
-
-int main()
-{
-
-  int n;
-  cout << "Enter number of elements\n";
-  cin >> n;
-  std::vector<int> v(n);
-  cout << "Enter all the elements\n";
-  for (int i = 0; i < n; ++i)
-  {
-    cin >> v[i];
-  }
-
-  CocktailSelectionSort(v, 0, n - 1);
-  cout << "Sorted elements are\n";
-  for (int i = 0; i < n; ++i)
-  {
-    cout << v[i] << " ";
-  }
-
-  return 0;
-}
diff --git a/sorting/NumericStringSort.cpp b/sorting/NumericStringSort.cpp
deleted file mode 100644
index 02f6964ba..000000000
--- a/sorting/NumericStringSort.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//Using general algorithms to sort a collection of strings results in alphanumeric sort.
-//If it is a numeric string, it leads to unnatural sorting
-
-//eg, an array of strings 1,10,100,2,20,200,3,30,300
-//would be sorted in that same order by using conventional sorting,
-//even though we know the correct sorting order is 1,2,3,10,20,30,100,200,300
-
-//This Programme uses a comparator to sort the array in Numerical order instead of Alphanumeric order
-
-#include <iostream>
-#include <string>
-#include <algorithm>
-using namespace std;
-
-bool NumericSort(string a, string b)
-{
-  while (a[0] == '0')
-  {
-    a.erase(a.begin());
-  }
-  while (b[0] == '0')
-  {
-    b.erase(b.begin());
-  }
-  int n = a.length();
-  int m = b.length();
-  if (n == m)
-    return a < b;
-  return n < m;
-}
-
-int main()
-{
-
-  int n;
-  cout << "Enter number of elements to be sorted Numerically\n";
-  cin >> n;
-
-  vector<string> v(n);
-  cout << "Enter the string of Numbers\n";
-  for (int i = 0; i < n; i++)
-  {
-    cin >> v[i];
-  }
-
-  sort(v.begin(), v.end());
-  cout << "Elements sorted normally \n";
-  for (int i = 0; i < n; i++)
-  {
-    cout << v[i] << " ";
-  }
-  cout << "\n";
-
-  sort(v.begin(), v.end(), NumericSort);
-  cout << "Elements sorted Numerically \n";
-  for (int i = 0; i < n; i++)
-  {
-    cout << v[i] << " ";
-  }
-
-  return 0;
-}
diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
new file mode 100644
index 000000000..12b7d4d32
--- /dev/null
+++ b/sorting/bead_sort.cpp
@@ -0,0 +1,54 @@
+// C++ program to implement gravity/bead sort
+#include <cstdio>
+#include <cstring>
+
+#define BEAD(i, j) beads[i * max + j]
+
+// function to perform the above algorithm
+void beadSort(int *a, int len) {
+    // Find the maximum element
+    int max = a[0];
+    for (int i = 1; i < len; i++)
+        if (a[i] > max) max = a[i];
+
+    // allocating memory
+    unsigned char beads[max * len];
+    memset(beads, 0, sizeof(beads));
+
+    // mark the beads
+    for (int i = 0; i < len; i++)
+        for (int j = 0; j < a[i]; j++) BEAD(i, j) = 1;
+
+    for (int j = 0; j < max; j++) {
+        // count how many beads are on each post
+        int sum = 0;
+        for (int i = 0; i < len; i++) {
+            sum += BEAD(i, j);
+            BEAD(i, j) = 0;
+        }
+
+        // Move beads down
+        for (int i = len - sum; i < len; i++) BEAD(i, j) = 1;
+    }
+
+    // Put sorted values in array using beads
+    for (int i = 0; i < len; i++) {
+        int j;
+        for (j = 0; j < max && BEAD(i, j); j++)
+            ;
+
+        a[i] = j;
+    }
+}
+
+// driver function to test the algorithm
+int main() {
+    int a[] = {5, 3, 1, 7, 4, 1, 1, 20};
+    int len = sizeof(a) / sizeof(a[0]);
+
+    beadSort(a, len);
+
+    for (int i = 0; i < len; i++) printf("%d ", a[i]);
+
+    return 0;
+}
diff --git a/sorting/bitonic_sort.cpp b/sorting/bitonic_sort.cpp
new file mode 100644
index 000000000..4d0981056
--- /dev/null
+++ b/sorting/bitonic_sort.cpp
@@ -0,0 +1,63 @@
+// Source : https://www.geeksforgeeks.org/bitonic-sort/
+
+/* C++ Program for Bitonic Sort. Note that this program
+   works only when size of input is a power of 2. */
+
+#include <algorithm>
+#include <iostream>
+
+/*The parameter dir indicates the sorting direction, ASCENDING
+   or DESCENDING; if (a[i] > a[j]) agrees with the direction,
+   then a[i] and a[j] are interchanged.*/
+void compAndSwap(int a[], int i, int j, int dir) {
+    if (dir == (a[i] > a[j])) std::swap(a[i], a[j]);
+}
+
+/*It recursively sorts a bitonic sequence in ascending order,
+  if dir = 1, and in descending order otherwise (means dir=0).
+  The sequence to be sorted starts at index position low,
+  the parameter cnt is the number of elements to be sorted.*/
+void bitonicMerge(int a[], int low, int cnt, int dir) {
+    if (cnt > 1) {
+        int k = cnt / 2;
+        for (int i = low; i < low + k; i++) compAndSwap(a, i, i + k, dir);
+        bitonicMerge(a, low, k, dir);
+        bitonicMerge(a, low + k, k, dir);
+    }
+}
+
+/* This function first produces a bitonic sequence by recursively
+    sorting its two halves in opposite sorting orders, and then
+    calls bitonicMerge to make them in the same order */
+void bitonicSort(int a[], int low, int cnt, int dir) {
+    if (cnt > 1) {
+        int k = cnt / 2;
+
+        // sort in ascending order since dir here is 1
+        bitonicSort(a, low, k, 1);
+
+        // sort in descending order since dir here is 0
+        bitonicSort(a, low + k, k, 0);
+
+        // Will merge wole sequence in ascending order
+        // since dir=1.
+        bitonicMerge(a, low, cnt, dir);
+    }
+}
+
+/* Caller of bitonicSort for sorting the entire array of
+   length N in ASCENDING order */
+void sort(int a[], int N, int up) { bitonicSort(a, 0, N, up); }
+
+// Driver code
+int main() {
+    int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
+    int N = sizeof(a) / sizeof(a[0]);
+
+    int up = 1;  // means sort in ascending order
+    sort(a, N, up);
+
+    std::cout << "Sorted array: \n";
+    for (int i = 0; i < N; i++) std::cout << a[i] << " ";
+    return 0;
+}
diff --git a/sorting/bubble_sort.cpp b/sorting/bubble_sort.cpp
new file mode 100644
index 000000000..794f65198
--- /dev/null
+++ b/sorting/bubble_sort.cpp
@@ -0,0 +1,83 @@
+/**
+ * @file
+ * @brief Bubble sort algorithm
+ *
+ * The working principle of the Bubble sort algorithm:
+
+Bubble sort algorithm is the bubble sorting algorithm. The most important reason
+for calling the bubble is that the largest number is thrown at the end of this
+algorithm. This is all about the logic. In each iteration, the largest number is
+expired and when iterations are completed, the sorting takes place.
+
+What is Swap?
+
+Swap in the software means that two variables are displaced.
+An additional variable is required for this operation. x = 5, y = 10.
+We want x = 10, y = 5. Here we create the most variable to do it.
+
+int z;
+z = x;
+x = y;
+y = z;
+
+The above process is a typical displacement process.
+When x assigns the value to x, the old value of x is lost.
+That's why we created a variable z to create the first value of the value of x,
+and finally, we have assigned to y.
+
+Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
+
+Bubble Sort Worst Case Performance is O (n²). Why is that? Because if you
+remember Big O Notation, we were calculating the complexity of the algorithms in
+the nested loops. The n * (n - 1) product gives us O (n²) performance. In the
+worst case all the steps of the cycle will occur. Bubble Sort (Avarage Case)
+Performance. Bubble Sort is not an optimal algorithm. in average, O (n²)
+performance is taken. Bubble Sort Best Case Performance. O (n). However, you
+can't get the best status in the code we shared above. This happens on the
+optimized bubble sort algorithm. It's right down there.
+*/
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    int n;
+    short swap_check = 1;
+    std::cout << "Enter the amount of numbers to sort: ";
+    std::cin >> n;
+    std::vector<int> numbers;
+    std::cout << "Enter " << n << " numbers: ";
+    int num;
+
+    // Input
+    for (int i = 0; i < n; i++) {
+        std::cin >> num;
+        numbers.push_back(num);
+    }
+
+    // Bubble Sorting
+    for (int i = 0; (i < n) && (swap_check == 1); i++) {
+        swap_check = 0;
+        for (int j = 0; j < n - 1 - i; j++) {
+            if (numbers[j] > numbers[j + 1]) {
+                swap_check = 1;
+                std::swap(numbers[j],
+                          numbers[j + 1]);  // by changing swap location.
+                                            // I mean, j. If the number is
+                                            // greater than j + 1, then it
+                                            // means the location.
+            }
+        }
+    }
+
+    // Output
+    std::cout << "\nSorted Array : ";
+    for (int i = 0; i < numbers.size(); i++) {
+        if (i != numbers.size() - 1) {
+            std::cout << numbers[i] << ", ";
+        } else {
+            std::cout << numbers[i] << std::endl;
+        }
+    }
+    return 0;
+}
diff --git a/sorting/bucketSort.cpp b/sorting/bucket_sort.cpp
similarity index 100%
rename from sorting/bucketSort.cpp
rename to sorting/bucket_sort.cpp
diff --git a/sorting/cocktail_selection_sort.cpp b/sorting/cocktail_selection_sort.cpp
new file mode 100644
index 000000000..a9abd86d5
--- /dev/null
+++ b/sorting/cocktail_selection_sort.cpp
@@ -0,0 +1,101 @@
+// Returns Sorted elements after performing Cocktail Selection Sort
+// It is a Sorting algorithm which chooses the minimum and maximum element in an
+// array simultaneously, and swaps it with the lowest and highest available
+// position iteratively or recursively
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+// Iterative Version
+
+void CocktailSelectionSort(std::vector<int> &vec, int low, int high) {
+    while (low <= high) {
+        int minimum = vec[low];
+        int minimumindex = low;
+        int maximum = vec[high];
+        int maximumindex = high;
+
+        for (int i = low; i <= high; i++) {
+            if (vec[i] >= maximum) {
+                maximum = vec[i];
+                maximumindex = i;
+            }
+            if (vec[i] <= minimum) {
+                minimum = vec[i];
+                minimumindex = i;
+            }
+        }
+        if (low != maximumindex || high != minimumindex) {
+            std::swap(vec[low], vec[minimumindex]);
+            std::swap(vec[high], vec[maximumindex]);
+        } else {
+            std::swap(vec[low], vec[high]);
+        }
+
+        low++;
+        high--;
+    }
+}
+
+// Recursive Version
+
+void CocktailSelectionSort_v2(std::vector<int> &vec, int low, int high) {
+    if (low >= high) return;
+
+    int minimum = vec[low];
+    int minimumindex = low;
+    int maximum = vec[high];
+    int maximumindex = high;
+
+    for (int i = low; i <= high; i++) {
+        if (vec[i] >= maximum) {
+            maximum = vec[i];
+            maximumindex = i;
+        }
+        if (vec[i] <= minimum) {
+            minimum = vec[i];
+            minimumindex = i;
+        }
+    }
+    if (low != maximumindex || high != minimumindex) {
+        std::swap(vec[low], vec[minimumindex]);
+        std::swap(vec[high], vec[maximumindex]);
+    } else {
+        std::swap(vec[low], vec[high]);
+    }
+
+    CocktailSelectionSort(vec, low + 1, high - 1);
+}
+
+// main function, select any one of iterative or recursive version
+
+int main() {
+    int n;
+    std::cout << "Enter number of elements\n";
+    std::cin >> n;
+    std::vector<int> v(n);
+    std::cout << "Enter all the elements\n";
+    for (int i = 0; i < n; ++i) {
+        std::cin >> v[i];
+    }
+
+    int method;
+    std::cout << "Enter method: \n\t0: iterative\n\t1: recursive:\t";
+    std::cin >> method;
+
+    if (method == 0) {
+        CocktailSelectionSort(v, 0, n - 1);
+    } else if (method == 1) {
+        CocktailSelectionSort_v2(v, 0, n - 1);
+    } else {
+        std::cerr << "Unknown method" << std::endl;
+        return -1;
+    }
+    std::cout << "Sorted elements are\n";
+    for (int i = 0; i < n; ++i) {
+        std::cout << v[i] << " ";
+    }
+
+    return 0;
+}
diff --git a/sorting/combsort.cpp b/sorting/comb_sort.cpp
similarity index 100%
rename from sorting/combsort.cpp
rename to sorting/comb_sort.cpp
diff --git a/sorting/CountingSortString.cpp b/sorting/counting_sort_string.cpp
similarity index 100%
rename from sorting/CountingSortString.cpp
rename to sorting/counting_sort_string.cpp
diff --git a/sorting/doxy.txt b/sorting/doxy.txt
deleted file mode 100644
index 68079276e..000000000
--- a/sorting/doxy.txt
+++ /dev/null
@@ -1,374 +0,0 @@
-# Doxyfile 1.8.13
-#This configuration file has been generated from Doxygen template.
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-DOXYFILE_ENCODING      = UTF-8
-PROJECT_NAME           = "My Project"
-PROJECT_NUMBER         =
-PROJECT_BRIEF          =
-PROJECT_LOGO           =
-OUTPUT_DIRECTORY       =
-CREATE_SUBDIRS         = NO
-ALLOW_UNICODE_NAMES    = NO
-OUTPUT_LANGUAGE        = English
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-ALWAYS_DETAILED_SEC    = NO
-INLINE_INHERITED_MEMB  = NO
-FULL_PATH_NAMES        = YES
-STRIP_FROM_PATH        =
-STRIP_FROM_INC_PATH    =
-SHORT_NAMES            = NO
-JAVADOC_AUTOBRIEF      = NO
-QT_AUTOBRIEF           = NO
-MULTILINE_CPP_IS_BRIEF = NO
-INHERIT_DOCS           = YES
-SEPARATE_MEMBER_PAGES  = NO
-TAB_SIZE               = 4
-ALIASES                =
-TCL_SUBST              =
-OPTIMIZE_OUTPUT_FOR_C  = NO
-OPTIMIZE_OUTPUT_JAVA   = NO
-OPTIMIZE_FOR_FORTRAN   = NO
-OPTIMIZE_OUTPUT_VHDL   = NO
-EXTENSION_MAPPING      =
-MARKDOWN_SUPPORT       = YES
-TOC_INCLUDE_HEADINGS   = 0
-AUTOLINK_SUPPORT       = YES
-BUILTIN_STL_SUPPORT    = NO
-CPP_CLI_SUPPORT        = NO
-SIP_SUPPORT            = NO
-IDL_PROPERTY_SUPPORT   = YES
-DISTRIBUTE_GROUP_DOC   = NO
-GROUP_NESTED_COMPOUNDS = NO
-SUBGROUPING            = YES
-INLINE_GROUPED_CLASSES = NO
-INLINE_SIMPLE_STRUCTS  = NO
-TYPEDEF_HIDES_STRUCT   = NO
-LOOKUP_CACHE_SIZE      = 0
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-EXTRACT_ALL            = NO
-EXTRACT_PRIVATE        = NO
-EXTRACT_PACKAGE        = NO
-EXTRACT_STATIC         = NO
-EXTRACT_LOCAL_CLASSES  = YES
-EXTRACT_LOCAL_METHODS  = NO
-EXTRACT_ANON_NSPACES   = NO
-HIDE_UNDOC_MEMBERS     = NO
-HIDE_UNDOC_CLASSES     = NO
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-INTERNAL_DOCS          = NO
-CASE_SENSE_NAMES       = YES
-HIDE_SCOPE_NAMES       = NO
-HIDE_COMPOUND_REFERENCE= NO
-SHOW_INCLUDE_FILES     = YES
-SHOW_GROUPED_MEMB_INC  = NO
-FORCE_LOCAL_INCLUDES   = NO
-INLINE_INFO            = YES
-SORT_MEMBER_DOCS       = YES
-SORT_BRIEF_DOCS        = NO
-SORT_MEMBERS_CTORS_1ST = NO
-SORT_GROUP_NAMES       = NO
-SORT_BY_SCOPE_NAME     = NO
-STRICT_PROTO_MATCHING  = NO
-GENERATE_TODOLIST      = YES
-GENERATE_TESTLIST      = YES
-GENERATE_BUGLIST       = YES
-GENERATE_DEPRECATEDLIST= YES
-ENABLED_SECTIONS       =
-MAX_INITIALIZER_LINES  = 30
-SHOW_USED_FILES        = YES
-SHOW_FILES             = YES
-SHOW_NAMESPACES        = YES
-FILE_VERSION_FILTER    =
-LAYOUT_FILE            =
-CITE_BIB_FILES         =
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET                  = NO
-WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
-WARN_IF_DOC_ERROR      = YES
-WARN_NO_PARAMDOC       = NO
-WARN_AS_ERROR          = NO
-WARN_FORMAT            = "$file:$line: $text"
-WARN_LOGFILE           =
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT                  =
-INPUT_ENCODING         = UTF-8
-FILE_PATTERNS          = *.c \
-                         *.cc \
-                         *.cxx \
-                         *.cpp \
-                         *.c++ \
-                         *.java \
-                         *.ii \
-                         *.ixx \
-                         *.ipp \
-                         *.i++ \
-                         *.inl \
-                         *.idl \
-                         *.ddl \
-                         *.odl \
-                         *.h \
-                         *.hh \
-                         *.hxx \
-                         *.hpp \
-                         *.h++ \
-                         *.cs \
-                         *.d \
-                         *.php \
-                         *.php4 \
-                         *.php5 \
-                         *.phtml \
-                         *.inc \
-                         *.m \
-                         *.markdown \
-                         *.md \
-                         *.mm \
-                         *.dox \
-                         *.py \
-                         *.pyw \
-                         *.f90 \
-                         *.f95 \
-                         *.f03 \
-                         *.f08 \
-                         *.f \
-                         *.for \
-                         *.tcl \
-                         *.vhd \
-                         *.vhdl \
-                         *.ucf \
-                         *.qsf
-RECURSIVE              = NO
-EXCLUDE                =
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       =
-EXCLUDE_SYMBOLS        =
-EXAMPLE_PATH           =
-EXAMPLE_PATTERNS       = *
-EXAMPLE_RECURSIVE      = NO
-IMAGE_PATH             =
-INPUT_FILTER           =
-FILTER_PATTERNS        =
-FILTER_SOURCE_FILES    = NO
-FILTER_SOURCE_PATTERNS =
-USE_MDFILE_AS_MAINPAGE =
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER         = NO
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = NO
-REFERENCES_RELATION    = NO
-REFERENCES_LINK_SOURCE = YES
-SOURCE_TOOLTIPS        = YES
-USE_HTAGS              = NO
-VERBATIM_HEADERS       = YES
-CLANG_ASSISTED_PARSING = NO
-CLANG_OPTIONS          =
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = YES
-COLS_IN_ALPHA_INDEX    = 5
-IGNORE_PREFIX          =
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML          = YES
-HTML_OUTPUT            = html
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            =
-HTML_FOOTER            =
-HTML_STYLESHEET        =
-HTML_EXTRA_STYLESHEET  =
-HTML_EXTRA_FILES       =
-HTML_COLORSTYLE_HUE    = 220
-HTML_COLORSTYLE_SAT    = 100
-HTML_COLORSTYLE_GAMMA  = 80
-HTML_TIMESTAMP         = NO
-HTML_DYNAMIC_SECTIONS  = NO
-HTML_INDEX_NUM_ENTRIES = 100
-GENERATE_DOCSET        = NO
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-DOCSET_PUBLISHER_NAME  = Publisher
-GENERATE_HTMLHELP      = NO
-CHM_FILE               =
-HHC_LOCATION           =
-GENERATE_CHI           = NO
-CHM_INDEX_ENCODING     =
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-GENERATE_QHP           = NO
-QCH_FILE               =
-QHP_NAMESPACE          = org.doxygen.Project
-QHP_VIRTUAL_FOLDER     = doc
-QHP_CUST_FILTER_NAME   =
-QHP_CUST_FILTER_ATTRS  =
-QHP_SECT_FILTER_ATTRS  =
-QHG_LOCATION           =
-GENERATE_ECLIPSEHELP   = NO
-ECLIPSE_DOC_ID         = org.doxygen.Project
-DISABLE_INDEX          = NO
-GENERATE_TREEVIEW      = NO
-ENUM_VALUES_PER_LINE   = 4
-TREEVIEW_WIDTH         = 250
-EXT_LINKS_IN_WINDOW    = NO
-FORMULA_FONTSIZE       = 10
-FORMULA_TRANSPARENT    = YES
-USE_MATHJAX            = NO
-MATHJAX_FORMAT         = HTML-CSS
-MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
-MATHJAX_EXTENSIONS     =
-MATHJAX_CODEFILE       =
-SEARCHENGINE           = YES
-SERVER_BASED_SEARCH    = NO
-EXTERNAL_SEARCH        = NO
-SEARCHENGINE_URL       =
-SEARCHDATA_FILE        = searchdata.xml
-EXTERNAL_SEARCH_ID     =
-EXTRA_SEARCH_MAPPINGS  =
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX         = NO
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         = latex
-MAKEINDEX_CMD_NAME     = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4
-EXTRA_PACKAGES         =
-LATEX_HEADER           =
-LATEX_FOOTER           =
-LATEX_EXTRA_STYLESHEET =
-LATEX_EXTRA_FILES      =
-PDF_HYPERLINKS         = YES
-USE_PDFLATEX           = YES
-LATEX_BATCHMODE        = NO
-LATEX_HIDE_INDICES     = NO
-LATEX_SOURCE_CODE      = NO
-LATEX_BIB_STYLE        = plain
-LATEX_TIMESTAMP        = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = NO
-RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    =
-RTF_EXTENSIONS_FILE    =
-RTF_SOURCE_CODE        = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_SUBDIR             =
-MAN_LINKS              = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML           = NO
-XML_OUTPUT             = xml
-XML_PROGRAMLISTING     = YES
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-GENERATE_DOCBOOK       = NO
-DOCBOOK_OUTPUT         = docbook
-DOCBOOK_PROGRAMLISTING = NO
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF   = NO
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX =
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING   = YES
-MACRO_EXPANSION        = NO
-EXPAND_ONLY_PREDEF     = NO
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           =
-INCLUDE_FILE_PATTERNS  =
-PREDEFINED             =
-EXPAND_AS_DEFINED      =
-SKIP_FUNCTION_MACROS   = YES
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-TAGFILES               =
-GENERATE_TAGFILE       =
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-EXTERNAL_PAGES         = YES
-PERL_PATH              = /usr/bin/perl
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-CLASS_DIAGRAMS         = YES
-MSCGEN_PATH            =
-DIA_PATH               =
-HIDE_UNDOC_RELATIONS   = YES
-HAVE_DOT               = YES
-DOT_NUM_THREADS        = 0
-DOT_FONTNAME           = Helvetica
-DOT_FONTSIZE           = 10
-DOT_FONTPATH           =
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = YES
-GROUP_GRAPHS           = YES
-UML_LOOK               = NO
-UML_LIMIT_NUM_FIELDS   = 10
-TEMPLATE_RELATIONS     = NO
-INCLUDE_GRAPH          = YES
-INCLUDED_BY_GRAPH      = YES
-CALL_GRAPH             = NO
-CALLER_GRAPH           = NO
-GRAPHICAL_HIERARCHY    = YES
-DIRECTORY_GRAPH        = YES
-DOT_IMAGE_FORMAT       = png
-INTERACTIVE_SVG        = NO
-DOT_PATH               =
-DOTFILE_DIRS           =
-MSCFILE_DIRS           =
-DIAFILE_DIRS           =
-PLANTUML_JAR_PATH      =
-PLANTUML_CFG_FILE      =
-PLANTUML_INCLUDE_PATH  =
-DOT_GRAPH_MAX_NODES    = 50
-MAX_DOT_GRAPH_DEPTH    = 0
-DOT_TRANSPARENT        = NO
-DOT_MULTI_TARGETS      = NO
-GENERATE_LEGEND        = YES
-DOT_CLEANUP            = YES
diff --git a/sorting/Insertion Sort.cpp b/sorting/insertion_sort.cpp
similarity index 100%
rename from sorting/Insertion Sort.cpp
rename to sorting/insertion_sort.cpp
diff --git a/sorting/makefile b/sorting/makefile
deleted file mode 100644
index 21d3186c6..000000000
--- a/sorting/makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-non_recursive_merge_sort: non_recursive_merge_sort.cpp
-	g++ -std=c++17 -o non_recursive_merge_sort non_recursive_merge_sort.cpp
-.PHONY: test
-.PHONY: doc
-.PHONY: clean
-test: non_recursive_merge_sort
-	./non_recursive_merge_sort
-doc: doxy.txt
-	doxygen doxy.txt
-clean:
-	rm -fr non_recursive_merge_sort html
diff --git a/sorting/Merge Sort.cpp b/sorting/merge_sort.cpp
similarity index 100%
rename from sorting/Merge Sort.cpp
rename to sorting/merge_sort.cpp
diff --git a/sorting/non_recursive_merge_sort.cpp b/sorting/non_recursive_merge_sort.cpp
index c6ca56376..ebfef1dcc 100644
--- a/sorting/non_recursive_merge_sort.cpp
+++ b/sorting/non_recursive_merge_sort.cpp
@@ -6,7 +6,7 @@
  */
 #include <cstddef>  // for size_t
 #include <utility>  // for std::move & std::remove_reference_t
-template<class Iterator>
+template <class Iterator>
 void merge(Iterator, Iterator, const Iterator, char[]);
 /// bottom-up merge sort which sorts elements in a non-decreasing order
 /**
@@ -17,13 +17,13 @@ void merge(Iterator, Iterator, const Iterator, char[]);
  * @param first points to the first element
  * @param last points to 1-step past the last element
  * @param n the number of elements
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const Iterator last,
                               const size_t n) {
     // create a buffer large enough to store all elements
     // dynamically allocated to comply with cpplint
-    char * buffer = new char[n * sizeof(*first)];
+    char* buffer = new char[n * sizeof(*first)];
     // buffer size can be optimized to largest power of 2 less than n elements
     // divide the container into equally-sized segments whose length start at 1
     // and keeps increasing by factors of 2
@@ -49,32 +49,28 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
  * @param r points to the right part, end of left part
  * @param e points to end of right part
  * @param b points at the buffer
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
     // create 2 pointers to point at the buffer
     auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
     // move the left part of the segment
-    for (Iterator t(l); r != t; ++t)
-        *p++ = std::move(*t);
+    for (Iterator t(l); r != t; ++t) *p++ = std::move(*t);
     // while neither the buffer nor the right part has been exhausted
     // move the smallest element of the two back to the container
-    while (e != r && c != p)
-        *l++ = std::move(*r < *c ? *r++ : *c++);
+    while (e != r && c != p) *l++ = std::move(*r < *c ? *r++ : *c++);
     // notice only one of the two following loops will be executed
     // while the right part hasn't bee exhausted, move it back
-    while (e != r)
-        *l++ = std::move(*r++);
+    while (e != r) *l++ = std::move(*r++);
     // while the buffer hasn't bee exhausted, move it back
-    while (c != p)
-        *l++ = std::move(*c++);
+    while (c != p) *l++ = std::move(*c++);
 }
 /// bottom-up merge sort which sorts elements in a non-decreasing order
 /**
  * @param first points to the first element
  * @param n the number of elements
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const size_t n) {
     non_recursive_merge_sort(first, first + n, n);
 }
@@ -82,8 +78,8 @@ void non_recursive_merge_sort(const Iterator first, const size_t n) {
 /**
  * @param first points to the first element
  * @param last points to 1-step past the last element
-*/
-template<class Iterator>
+ */
+template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const Iterator last) {
     non_recursive_merge_sort(first, last, last - first);
 }
@@ -92,15 +88,15 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last) {
  * Currently, it only creates output for non_recursive_merge_sort.cpp, but if
  * it has proven its efficacy it can be expanded to other files.
  * The configuration file is named doxy.txt and has been auto-generated too.
-*/
+ */
 // the remaining of this file is only for testing. It can erased to to convert
 // it into a header file for later re-use.
 #include <iostream>
-int main(int argc, char ** argv) {
+int main(int argc, char** argv) {
     int size;
     std::cout << "Enter the number of elements : ";
     std::cin >> size;
-    int * arr = new int[size];
+    int* arr = new int[size];
     for (int i = 0; i < size; ++i) {
         std::cout << "arr[" << i << "] = ";
         std::cin >> arr[i];
diff --git a/sorting/numeric_string_sort.cpp b/sorting/numeric_string_sort.cpp
new file mode 100644
index 000000000..8b86bb29d
--- /dev/null
+++ b/sorting/numeric_string_sort.cpp
@@ -0,0 +1,54 @@
+// Using general algorithms to sort a collection of strings results in
+// alphanumeric sort. If it is a numeric string, it leads to unnatural sorting
+
+// eg, an array of strings 1,10,100,2,20,200,3,30,300
+// would be sorted in that same order by using conventional sorting,
+// even though we know the correct sorting order is 1,2,3,10,20,30,100,200,300
+
+// This Programme uses a comparator to sort the array in Numerical order instead
+// of Alphanumeric order
+
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <vector>
+
+bool NumericSort(std::string a, std::string b) {
+    while (a[0] == '0') {
+        a.erase(a.begin());
+    }
+    while (b[0] == '0') {
+        b.erase(b.begin());
+    }
+    int n = a.length();
+    int m = b.length();
+    if (n == m) return a < b;
+    return n < m;
+}
+
+int main() {
+    int n;
+    std::cout << "Enter number of elements to be sorted Numerically\n";
+    std::cin >> n;
+
+    std::vector<std::string> v(n);
+    std::cout << "Enter the string of Numbers\n";
+    for (int i = 0; i < n; i++) {
+        std::cin >> v[i];
+    }
+
+    sort(v.begin(), v.end());
+    std::cout << "Elements sorted normally \n";
+    for (int i = 0; i < n; i++) {
+        std::cout << v[i] << " ";
+    }
+    std::cout << "\n";
+
+    std::sort(v.begin(), v.end(), NumericSort);
+    std::cout << "Elements sorted Numerically \n";
+    for (int i = 0; i < n; i++) {
+        std::cout << v[i] << " ";
+    }
+
+    return 0;
+}
diff --git a/sorting/OddEven Sort.cpp b/sorting/odd_even_sort.cpp
similarity index 100%
rename from sorting/OddEven Sort.cpp
rename to sorting/odd_even_sort.cpp
diff --git a/sorting/Quick Sort.cpp b/sorting/quick_sort.cpp
similarity index 100%
rename from sorting/Quick Sort.cpp
rename to sorting/quick_sort.cpp
diff --git a/sorting/Radix Sort.cpp b/sorting/radix_sort.cpp
similarity index 100%
rename from sorting/Radix Sort.cpp
rename to sorting/radix_sort.cpp
diff --git a/sorting/Selection Sort.cpp b/sorting/selection_sort.cpp
similarity index 100%
rename from sorting/Selection Sort.cpp
rename to sorting/selection_sort.cpp
diff --git a/sorting/Shell Sort.cpp b/sorting/shell_sort.cpp
similarity index 100%
rename from sorting/Shell Sort.cpp
rename to sorting/shell_sort.cpp
diff --git a/sorting/Slow Sort.cpp b/sorting/slow_sort.cpp
similarity index 100%
rename from sorting/Slow Sort.cpp
rename to sorting/slow_sort.cpp
diff --git a/sorting/Tim Sort.cpp b/sorting/tim_sort.cpp
similarity index 100%
rename from sorting/Tim Sort.cpp
rename to sorting/tim_sort.cpp

From 887bff8a9ead3c19b03b73f91384e92de98d05cf Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 11:46:24 -0400
Subject: [PATCH 098/290] sorting fixes for MSVC and CPPLINT

(cherry picked from commit 76a5f572d5d9834585201836183027e3575b1e55)
---
 sorting/bead_sort.cpp   |  5 ++--
 sorting/bucket_sort.cpp | 51 ++++++++++++++++++-----------------------
 sorting/comb_sort.cpp   | 47 +++++++++++++++----------------------
 3 files changed, 43 insertions(+), 60 deletions(-)

diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
index 12b7d4d32..d34706073 100644
--- a/sorting/bead_sort.cpp
+++ b/sorting/bead_sort.cpp
@@ -12,8 +12,8 @@ void beadSort(int *a, int len) {
         if (a[i] > max) max = a[i];
 
     // allocating memory
-    unsigned char beads[max * len];
-    memset(beads, 0, sizeof(beads));
+    unsigned char *beads = new unsigned char[max * len];
+    memset(beads, 0, max * len);
 
     // mark the beads
     for (int i = 0; i < len; i++)
@@ -39,6 +39,7 @@ void beadSort(int *a, int len) {
 
         a[i] = j;
     }
+    delete[] beads;
 }
 
 // driver function to test the algorithm
diff --git a/sorting/bucket_sort.cpp b/sorting/bucket_sort.cpp
index 0ffbf8e4c..f120f04fc 100644
--- a/sorting/bucket_sort.cpp
+++ b/sorting/bucket_sort.cpp
@@ -1,42 +1,35 @@
 // C++ program to sort an array using bucket sort
-#include <iostream>
 #include <algorithm>
+#include <iostream>
 #include <vector>
-using namespace std;
 
 // Function to sort arr[] of size n using bucket sort
-void bucketSort(float arr[], int n)
-{
-   // 1) Create n empty buckets
-   vector<float> b[n];
+void bucketSort(float arr[], int n) {
+    // 1) Create n empty buckets
+    std::vector<float> b[n];
 
-   // 2) Put array elements in different buckets
-   for (int i = 0; i < n; i++)
-   {
-      int bi = n * arr[i]; // Index in bucket
-      b[bi].push_back(arr[i]);
-   }
+    // 2) Put array elements in different buckets
+    for (int i = 0; i < n; i++) {
+        int bi = n * arr[i];  // Index in bucket
+        b[bi].push_back(arr[i]);
+    }
 
-   // 3) Sort individual buckets
-   for (int i = 0; i < n; i++)
-      sort(b[i].begin(), b[i].end());
+    // 3) Sort individual buckets
+    for (int i = 0; i < n; i++) std::sort(b[i].begin(), b[i].end());
 
-   // 4) Concatenate all buckets into arr[]
-   int index = 0;
-   for (int i = 0; i < n; i++)
-      for (int j = 0; j < b[i].size(); j++)
-         arr[index++] = b[i][j];
+    // 4) Concatenate all buckets into arr[]
+    int index = 0;
+    for (int i = 0; i < n; i++)
+        for (int j = 0; j < b[i].size(); j++) arr[index++] = b[i][j];
 }
 
 /* Driver program to test above funtion */
-int main()
-{
-   float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
-   int n = sizeof(arr) / sizeof(arr[0]);
-   bucketSort(arr, n);
+int main() {
+    float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    bucketSort(arr, n);
 
-   cout << "Sorted array is \n";
-   for (int i = 0; i < n; i++)
-      cout << arr[i] << " ";
-   return 0;
+    std::cout << "Sorted array is \n";
+    for (int i = 0; i < n; i++) std::cout << arr[i] << " ";
+    return 0;
 }
diff --git a/sorting/comb_sort.cpp b/sorting/comb_sort.cpp
index 2209c96fc..feed4ba44 100644
--- a/sorting/comb_sort.cpp
+++ b/sorting/comb_sort.cpp
@@ -1,59 +1,48 @@
-//Kind of better version of Bubble sort.
-//While Bubble sort is comparering adjacent value, Combsort is using gap larger than 1
-//Best case: O(n)
-//Worst case: O(n ^ 2)
+// Kind of better version of Bubble sort.
+// While Bubble sort is comparering adjacent value, Combsort is using gap larger
+// than 1 Best case: O(n) Worst case: O(n ^ 2)
 
 #include <iostream>
 
-using namespace std;
-
 int a[100005];
 int n;
 
-int FindNextGap(int x)
-{
+int FindNextGap(int x) {
     x = (x * 10) / 13;
 
-    return max(1, x);
+    return std::max(1, x);
 }
 
-void CombSort(int a[], int l, int r)
-{
-    //Init gap
+void CombSort(int a[], int l, int r) {
+    // Init gap
     int gap = n;
 
-    //Initialize swapped as true to make sure that loop runs
+    // Initialize swapped as true to make sure that loop runs
     bool swapped = true;
 
-    //Keep running until gap = 1 or none elements were swapped
-    while (gap != 1 || swapped)
-    {
-        //Find next gap
+    // Keep running until gap = 1 or none elements were swapped
+    while (gap != 1 || swapped) {
+        // Find next gap
         gap = FindNextGap(gap);
 
         swapped = false;
 
         // Compare all elements with current gap
-        for (int i = l; i <= r - gap; ++i)
-        {
-            if (a[i] > a[i + gap])
-            {
-                swap(a[i], a[i + gap]);
+        for (int i = l; i <= r - gap; ++i) {
+            if (a[i] > a[i + gap]) {
+                std::swap(a[i], a[i + gap]);
                 swapped = true;
             }
         }
     }
 }
 
-int main()
-{
-    cin >> n;
-    for (int i = 1; i <= n; ++i)
-        cin >> a[i];
+int main() {
+    std::cin >> n;
+    for (int i = 1; i <= n; ++i) std::cin >> a[i];
 
     CombSort(a, 1, n);
 
-    for (int i = 1; i <= n; ++i)
-        cout << a[i] << ' ';
+    for (int i = 1; i <= n; ++i) std::cout << a[i] << ' ';
     return 0;
 }

From 77e781f709308a393b8e0ab11ac2f6b5dec15a68 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 12:15:12 -0400
Subject: [PATCH 099/290] cpplint and msvc fixes for - sorting

(cherry picked from commit 0d8e015d15b87ea188b75f1f70b7be614cdf86cd)
---
 sorting/bead_sort.cpp               |  4 +--
 sorting/bubble_sort.cpp             |  8 +++---
 sorting/cocktail_selection_sort.cpp | 44 ++++++++++++++---------------
 3 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
index d34706073..a1a54c1e0 100644
--- a/sorting/bead_sort.cpp
+++ b/sorting/bead_sort.cpp
@@ -34,8 +34,8 @@ void beadSort(int *a, int len) {
     // Put sorted values in array using beads
     for (int i = 0; i < len; i++) {
         int j;
-        for (j = 0; j < max && BEAD(i, j); j++)
-            ;
+        for (j = 0; j < max && BEAD(i, j); j++) {
+        }
 
         a[i] = j;
     }
diff --git a/sorting/bubble_sort.cpp b/sorting/bubble_sort.cpp
index 794f65198..c43e425fc 100644
--- a/sorting/bubble_sort.cpp
+++ b/sorting/bubble_sort.cpp
@@ -42,7 +42,7 @@ optimized bubble sort algorithm. It's right down there.
 
 int main() {
     int n;
-    short swap_check = 1;
+    bool swap_check = true;
     std::cout << "Enter the amount of numbers to sort: ";
     std::cin >> n;
     std::vector<int> numbers;
@@ -56,11 +56,11 @@ int main() {
     }
 
     // Bubble Sorting
-    for (int i = 0; (i < n) && (swap_check == 1); i++) {
-        swap_check = 0;
+    for (int i = 0; (i < n) && (swap_check); i++) {
+        swap_check = false;
         for (int j = 0; j < n - 1 - i; j++) {
             if (numbers[j] > numbers[j + 1]) {
-                swap_check = 1;
+                swap_check = true;
                 std::swap(numbers[j],
                           numbers[j + 1]);  // by changing swap location.
                                             // I mean, j. If the number is
diff --git a/sorting/cocktail_selection_sort.cpp b/sorting/cocktail_selection_sort.cpp
index a9abd86d5..ab6229996 100644
--- a/sorting/cocktail_selection_sort.cpp
+++ b/sorting/cocktail_selection_sort.cpp
@@ -9,28 +9,28 @@
 
 // Iterative Version
 
-void CocktailSelectionSort(std::vector<int> &vec, int low, int high) {
+void CocktailSelectionSort(std::vector<int> *vec, int low, int high) {
     while (low <= high) {
-        int minimum = vec[low];
+        int minimum = (*vec)[low];
         int minimumindex = low;
-        int maximum = vec[high];
+        int maximum = (*vec)[high];
         int maximumindex = high;
 
         for (int i = low; i <= high; i++) {
-            if (vec[i] >= maximum) {
-                maximum = vec[i];
+            if ((*vec)[i] >= maximum) {
+                maximum = (*vec)[i];
                 maximumindex = i;
             }
-            if (vec[i] <= minimum) {
-                minimum = vec[i];
+            if ((*vec)[i] <= minimum) {
+                minimum = (*vec)[i];
                 minimumindex = i;
             }
         }
         if (low != maximumindex || high != minimumindex) {
-            std::swap(vec[low], vec[minimumindex]);
-            std::swap(vec[high], vec[maximumindex]);
+            std::swap((*vec)[low], (*vec)[minimumindex]);
+            std::swap((*vec)[high], (*vec)[maximumindex]);
         } else {
-            std::swap(vec[low], vec[high]);
+            std::swap((*vec)[low], (*vec)[high]);
         }
 
         low++;
@@ -40,29 +40,29 @@ void CocktailSelectionSort(std::vector<int> &vec, int low, int high) {
 
 // Recursive Version
 
-void CocktailSelectionSort_v2(std::vector<int> &vec, int low, int high) {
+void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high) {
     if (low >= high) return;
 
-    int minimum = vec[low];
+    int minimum = (*vec)[low];
     int minimumindex = low;
-    int maximum = vec[high];
+    int maximum = (*vec)[high];
     int maximumindex = high;
 
     for (int i = low; i <= high; i++) {
-        if (vec[i] >= maximum) {
-            maximum = vec[i];
+        if ((*vec)[i] >= maximum) {
+            maximum = (*vec)[i];
             maximumindex = i;
         }
-        if (vec[i] <= minimum) {
-            minimum = vec[i];
+        if ((*vec)[i] <= minimum) {
+            minimum = (*vec)[i];
             minimumindex = i;
         }
     }
     if (low != maximumindex || high != minimumindex) {
-        std::swap(vec[low], vec[minimumindex]);
-        std::swap(vec[high], vec[maximumindex]);
+        std::swap((*vec)[low], (*vec)[minimumindex]);
+        std::swap((*vec)[high], (*vec)[maximumindex]);
     } else {
-        std::swap(vec[low], vec[high]);
+        std::swap((*vec)[low], (*vec)[high]);
     }
 
     CocktailSelectionSort(vec, low + 1, high - 1);
@@ -85,9 +85,9 @@ int main() {
     std::cin >> method;
 
     if (method == 0) {
-        CocktailSelectionSort(v, 0, n - 1);
+        CocktailSelectionSort(&v, 0, n - 1);
     } else if (method == 1) {
-        CocktailSelectionSort_v2(v, 0, n - 1);
+        CocktailSelectionSort_v2(&v, 0, n - 1);
     } else {
         std::cerr << "Unknown method" << std::endl;
         return -1;

From 09f073306527f5f5d47f1f0c046d526902f080d0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 12:31:49 -0400
Subject: [PATCH 100/290] fix dynamic array

(cherry picked from commit 717f5c8f01c1d5559320e118ccc8eabdf602e8ff)
---
 sorting/bucket_sort.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sorting/bucket_sort.cpp b/sorting/bucket_sort.cpp
index f120f04fc..c43865281 100644
--- a/sorting/bucket_sort.cpp
+++ b/sorting/bucket_sort.cpp
@@ -6,7 +6,7 @@
 // Function to sort arr[] of size n using bucket sort
 void bucketSort(float arr[], int n) {
     // 1) Create n empty buckets
-    std::vector<float> b[n];
+    std::vector<float> *b = new std::vector<float>[n];
 
     // 2) Put array elements in different buckets
     for (int i = 0; i < n; i++) {
@@ -21,6 +21,7 @@ void bucketSort(float arr[], int n) {
     int index = 0;
     for (int i = 0; i < n; i++)
         for (int j = 0; j < b[i].size(); j++) arr[index++] = b[i][j];
+    delete[] b;
 }
 
 /* Driver program to test above funtion */

From 231c99f8802346b84962bb087f37ed34d1a0d3fc Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:02:10 -0400
Subject: [PATCH 101/290] fix dynamic array issues in sorting folder

(cherry picked from commit 01b69fcb249c30d4f1795766bf4cc617d8200ab3)
---
 sorting/comb_sort.cpp      |   1 +
 sorting/insertion_sort.cpp |  62 ++++++++++----------
 sorting/merge_sort.cpp     |  66 +++++++++------------
 sorting/quick_sort.cpp     |  51 +++++++---------
 sorting/radix_sort.cpp     | 116 +++++++++++++++++--------------------
 sorting/shell_sort.cpp     |  72 ++++++++++-------------
 sorting/slow_sort.cpp      |  82 +++++++++++++-------------
 sorting/swap_sort.cpp      |   7 ++-
 sorting/tim_sort.cpp       | 110 ++++++++++++++++-------------------
 9 files changed, 256 insertions(+), 311 deletions(-)

diff --git a/sorting/comb_sort.cpp b/sorting/comb_sort.cpp
index feed4ba44..1b0a4d706 100644
--- a/sorting/comb_sort.cpp
+++ b/sorting/comb_sort.cpp
@@ -2,6 +2,7 @@
 // While Bubble sort is comparering adjacent value, Combsort is using gap larger
 // than 1 Best case: O(n) Worst case: O(n ^ 2)
 
+#include <algorithm>
 #include <iostream>
 
 int a[100005];
diff --git a/sorting/insertion_sort.cpp b/sorting/insertion_sort.cpp
index 2563acaf8..fe920ca59 100644
--- a/sorting/insertion_sort.cpp
+++ b/sorting/insertion_sort.cpp
@@ -1,40 +1,36 @@
-//Insertion Sort
+// Insertion Sort
 
 #include <iostream>
-using namespace std;
 
-int main()
-{
-	int n;
-	cout << "\nEnter the length of your array : ";
-	cin >> n;
-	int Array[n];
-	cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
+int main() {
+    int n;
+    std::cout << "\nEnter the length of your array : ";
+    std::cin >> n;
+    int *Array = new int[n];
+    std::cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
 
-	//Input
-	for (int i = 0; i < n; i++)
-	{
-		cin >> Array[i];
-	}
+    // Input
+    for (int i = 0; i < n; i++) {
+        std::cin >> Array[i];
+    }
 
-	//Sorting
-	for (int i = 1; i < n; i++)
-	{
-		int temp = Array[i];
-		int j = i - 1;
-		while (j >= 0 && temp < Array[j])
-		{
-			Array[j + 1] = Array[j];
-			j--;
-		}
-		Array[j + 1] = temp;
-	}
+    // Sorting
+    for (int i = 1; i < n; i++) {
+        int temp = Array[i];
+        int j = i - 1;
+        while (j >= 0 && temp < Array[j]) {
+            Array[j + 1] = Array[j];
+            j--;
+        }
+        Array[j + 1] = temp;
+    }
 
-	//Output
-	cout << "\nSorted Array : ";
-	for (int i = 0; i < n; i++)
-	{
-		cout << Array[i] << "\t";
-	}
-	return 0;
+    // Output
+    std::cout << "\nSorted Array : ";
+    for (int i = 0; i < n; i++) {
+        std::cout << Array[i] << "\t";
+    }
+
+    delete[] Array;
+    return 0;
 }
diff --git a/sorting/merge_sort.cpp b/sorting/merge_sort.cpp
index b8edc8851..82ab869cd 100644
--- a/sorting/merge_sort.cpp
+++ b/sorting/merge_sort.cpp
@@ -1,57 +1,47 @@
 #include <iostream>
-using namespace std;
 
-void merge(int arr[], int l, int m, int r)
-{
+void merge(int arr[], int l, int m, int r) {
     int i, j, k;
     int n1 = m - l + 1;
     int n2 = r - m;
 
-    int L[n1], R[n2];
+    int *L = new int[n1], *R = new int[n2];
 
-    for (i = 0; i < n1; i++)
-        L[i] = arr[l + i];
-    for (j = 0; j < n2; j++)
-        R[j] = arr[m + 1 + j];
+    for (i = 0; i < n1; i++) L[i] = arr[l + i];
+    for (j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
 
     i = 0;
     j = 0;
     k = l;
-    while (i < n1 && j < n2)
-    {
-        if (L[i] <= R[j])
-        {
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) {
             arr[k] = L[i];
             i++;
-        }
-        else
-        {
+        } else {
             arr[k] = R[j];
             j++;
         }
         k++;
     }
 
-    while (i < n1)
-    {
+    while (i < n1) {
         arr[k] = L[i];
         i++;
         k++;
     }
 
-    while (j < n2)
-    {
+    while (j < n2) {
         arr[k] = R[j];
         j++;
         k++;
     }
+
+    delete[] L;
+    delete[] R;
 }
 
-void mergeSort(int arr[], int l, int r)
-{
-    if (l < r)
-    {
-
+void mergeSort(int arr[], int l, int r) {
+    if (l < r) {
         int m = l + (r - l) / 2;
 
         mergeSort(arr, l, m);
@@ -61,33 +51,31 @@ void mergeSort(int arr[], int l, int r)
     }
 }
 
-void show(int A[], int size)
-{
+void show(int A[], int size) {
     int i;
-    for (i = 0; i < size; i++)
-        cout << A[i] << "\n";
+    for (i = 0; i < size; i++) std::cout << A[i] << "\n";
 }
 
-int main()
-{
+int main() {
     int size;
-    cout << "\nEnter the number of elements : ";
+    std::cout << "\nEnter the number of elements : ";
 
-    cin >> size;
+    std::cin >> size;
 
-    int arr[size];
+    int *arr = new int[size];
 
-    cout << "\nEnter the unsorted elements : ";
+    std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i)
-    {
-        cout << "\n";
-        cin >> arr[i];
+    for (int i = 0; i < size; ++i) {
+        std::cout << "\n";
+        std::cin >> arr[i];
     }
 
     mergeSort(arr, 0, size);
 
-    cout << "Sorted array\n";
+    std::cout << "Sorted array\n";
     show(arr, size);
+
+    delete[] arr;
     return 0;
 }
diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
index 0b807898f..489e10965 100644
--- a/sorting/quick_sort.cpp
+++ b/sorting/quick_sort.cpp
@@ -1,19 +1,15 @@
 /* C implementation QuickSort */
 #include <iostream>
-using namespace std;
 
-int partition(int arr[], int low, int high)
-{
-    int pivot = arr[high]; // pivot
-    int i = (low - 1);     // Index of smaller element
+int partition(int arr[], int low, int high) {
+    int pivot = arr[high];  // pivot
+    int i = (low - 1);      // Index of smaller element
 
-    for (int j = low; j < high; j++)
-    {
+    for (int j = low; j < high; j++) {
         // If current element is smaller than or
         // equal to pivot
-        if (arr[j] <= pivot)
-        {
-            i++; // increment index of smaller element
+        if (arr[j] <= pivot) {
+            i++;  // increment index of smaller element
             int temp = arr[i];
             arr[i] = arr[j];
             arr[j] = temp;
@@ -25,11 +21,8 @@ int partition(int arr[], int low, int high)
     return (i + 1);
 }
 
-void quickSort(int arr[], int low, int high)
-{
-    if (low < high)
-    {
-
+void quickSort(int arr[], int low, int high) {
+    if (low < high) {
         int p = partition(arr, low, high);
 
         quickSort(arr, low, p - 1);
@@ -37,31 +30,29 @@ void quickSort(int arr[], int low, int high)
     }
 }
 
-void show(int arr[], int size)
-{
-    for (int i = 0; i < size; i++)
-        cout << arr[i] << "\n";
+void show(int arr[], int size) {
+    for (int i = 0; i < size; i++) std::cout << arr[i] << "\n";
 }
 
 // Driver program to test above functions
-int main()
-{
+int main() {
     int size;
-    cout << "\nEnter the number of elements : ";
+    std::cout << "\nEnter the number of elements : ";
 
-    cin >> size;
+    std::cin >> size;
 
-    int arr[size];
+    int *arr = new int[size];
 
-    cout << "\nEnter the unsorted elements : ";
+    std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i)
-    {
-        cout << "\n";
-        cin >> arr[i];
+    for (int i = 0; i < size; ++i) {
+        std::cout << "\n";
+        std::cin >> arr[i];
     }
     quickSort(arr, 0, size);
-    cout << "Sorted array\n";
+    std::cout << "Sorted array\n";
     show(arr, size);
+
+    delete[] arr;
     return 0;
 }
diff --git a/sorting/radix_sort.cpp b/sorting/radix_sort.cpp
index 09c91bb22..e5bc3db84 100644
--- a/sorting/radix_sort.cpp
+++ b/sorting/radix_sort.cpp
@@ -1,68 +1,58 @@
-#include <iostream>
-#include <cstdlib>
 #include <cmath>
+#include <cstdlib>
 #include <cstring>
-using namespace std;
-void radixsort(int a[], int n)
-{
-	int count[10];
-	int output[n];
-	memset(output, 0, sizeof(output));
-	memset(count, 0, sizeof(count));
-	int max = 0;
-	for (int i = 0; i < n; ++i)
-	{
-		if (a[i] > max)
-		{
-			max = a[i];
-		}
-	}
-	int maxdigits = 0;
-	while (max)
-	{
-		maxdigits++;
-		max /= 10;
-	}
-	for (int j = 0; j < maxdigits; j++)
-	{
-		for (int i = 0; i < n; i++)
-		{
-			int t = pow(10, j);
-			count[(a[i] % (10 * t)) / t]++;
-		}
-		int k = 0;
-		for (int p = 0; p < 10; p++)
-		{
-			for (int i = 0; i < n; i++)
-			{
-				int t = pow(10, j);
-				if ((a[i] % (10 * t)) / t == p)
-				{
-					output[k] = a[i];
-					k++;
-				}
-			}
-		}
-		memset(count, 0, sizeof(count));
-		for (int i = 0; i < n; ++i)
-		{
-			a[i] = output[i];
-		}
-	}
+#include <iostream>
+
+void radixsort(int a[], int n) {
+    int count[10];
+    int* output = new int[n];
+    memset(output, 0, n * sizeof(*output));
+    memset(count, 0, sizeof(count));
+    int max = 0;
+    for (int i = 0; i < n; ++i) {
+        if (a[i] > max) {
+            max = a[i];
+        }
+    }
+    int maxdigits = 0;
+    while (max) {
+        maxdigits++;
+        max /= 10;
+    }
+    for (int j = 0; j < maxdigits; j++) {
+        for (int i = 0; i < n; i++) {
+            int t = std::pow(10, j);
+            count[(a[i] % (10 * t)) / t]++;
+        }
+        int k = 0;
+        for (int p = 0; p < 10; p++) {
+            for (int i = 0; i < n; i++) {
+                int t = std::pow(10, j);
+                if ((a[i] % (10 * t)) / t == p) {
+                    output[k] = a[i];
+                    k++;
+                }
+            }
+        }
+        memset(count, 0, sizeof(count));
+        for (int i = 0; i < n; ++i) {
+            a[i] = output[i];
+        }
+    }
+    delete[] output;
 }
-void print(int a[], int n)
-{
-	for (int i = 0; i < n; ++i)
-	{
-		cout << a[i] << " ";
-	}
-	cout << endl;
+
+void print(int a[], int n) {
+    for (int i = 0; i < n; ++i) {
+        std::cout << a[i] << " ";
+    }
+    std::cout << std::endl;
 }
-int main(int argc, char const *argv[])
-{
-	int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
-	int n = sizeof(a) / sizeof(a[0]);
-	radixsort(a, n);
-	print(a, n);
-	return 0;
+
+int main(int argc, char const* argv[]) {
+    int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
+    int n = sizeof(a) / sizeof(a[0]);
+    radixsort(a, n);
+    print(a, n);
+    return 0;
 }
\ No newline at end of file
diff --git a/sorting/shell_sort.cpp b/sorting/shell_sort.cpp
index b08c7ffd8..eb701478d 100644
--- a/sorting/shell_sort.cpp
+++ b/sorting/shell_sort.cpp
@@ -1,45 +1,37 @@
 #include <iostream>
-using namespace std;
 
-int main()
-{
-	int size = 10;
-	int array[size];
-	// Input
-	cout << "\nHow many numbers do want to enter in unsorted array : ";
-	cin >> size;
-	cout << "\nEnter the numbers for unsorted array : ";
-	for (int i = 0; i < size; i++)
-	{
-		cin >> array[i];
-	}
+int main() {
+    int size = 10;
+    int* array = new int[size];
+    // Input
+    std::cout << "\nHow many numbers do want to enter in unsorted array : ";
+    std::cin >> size;
+    std::cout << "\nEnter the numbers for unsorted array : ";
+    for (int i = 0; i < size; i++) {
+        std::cin >> array[i];
+    }
 
-	// Sorting
-	for (int i = size / 2; i > 0; i = i / 2)
-	{
-		for (int j = i; j < size; j++)
-		{
-			for (int k = j - i; k >= 0; k = k - i)
-			{
-				if (array[k] < array[k + i])
-				{
-					break;
-				}
-				else
-				{
-					int temp = array[k + i];
-					array[k + i] = array[k];
-					array[k] = temp;
-				}
-			}
-		}
-	}
+    // Sorting
+    for (int i = size / 2; i > 0; i = i / 2) {
+        for (int j = i; j < size; j++) {
+            for (int k = j - i; k >= 0; k = k - i) {
+                if (array[k] < array[k + i]) {
+                    break;
+                } else {
+                    int temp = array[k + i];
+                    array[k + i] = array[k];
+                    array[k] = temp;
+                }
+            }
+        }
+    }
 
-	// Output
-	cout << "\nSorted array : ";
-	for (int i = 0; i < size; ++i)
-	{
-		cout << array[i] << "\t";
-	}
-	return 0;
+    // Output
+    std::cout << "\nSorted array : ";
+    for (int i = 0; i < size; ++i) {
+        std::cout << array[i] << "\t";
+    }
+
+    delete[] array;
+    return 0;
 }
diff --git a/sorting/slow_sort.cpp b/sorting/slow_sort.cpp
index f8f7e74b8..2872b37d8 100644
--- a/sorting/slow_sort.cpp
+++ b/sorting/slow_sort.cpp
@@ -1,57 +1,55 @@
-//Returns the sorted vector after performing SlowSort
-//It is a sorting algorithm that is of humorous nature and not useful.
-//It's based on the principle of multiply and surrender, a tongue-in-cheek joke of divide and conquer.
-//It was published in 1986 by Andrei Broder and Jorge Stolfi in their paper Pessimal Algorithms and Simplexity Analysis.
-//This algorithm multiplies a single problem into multiple subproblems
-//It is interesting because it is provably the least efficient sorting algorithm that can be built asymptotically,
-//and with the restriction that such an algorithm, while being slow, must still all the time be working towards a result.
+// Returns the sorted vector after performing SlowSort
+// It is a sorting algorithm that is of humorous nature and not useful.
+// It's based on the principle of multiply and surrender, a tongue-in-cheek joke
+// of divide and conquer. It was published in 1986 by Andrei Broder and Jorge
+// Stolfi in their paper Pessimal Algorithms and Simplexity Analysis. This
+// algorithm multiplies a single problem into multiple subproblems It is
+// interesting because it is provably the least efficient sorting algorithm that
+// can be built asymptotically, and with the restriction that such an algorithm,
+// while being slow, must still all the time be working towards a result.
 
 #include <iostream>
 using namespace std;
 
-void SlowSort(int a[], int i, int j)
-{
-  if (i >= j)
-    return;
-  int m = i + (j - i) / 2; //midpoint, implemented this way to avoid overflow
-  int temp;
-  SlowSort(a, i, m);
-  SlowSort(a, m + 1, j);
-  if (a[j] < a[m])
-  {
-    temp = a[j]; //swapping a[j] & a[m]
-    a[j] = a[m];
-    a[m] = temp;
-  }
-  SlowSort(a, i, j - 1);
+void SlowSort(int a[], int i, int j) {
+    if (i >= j) return;
+    int m = i + (j - i) / 2;  // midpoint, implemented this way to avoid
+                              // overflow
+    int temp;
+    SlowSort(a, i, m);
+    SlowSort(a, m + 1, j);
+    if (a[j] < a[m]) {
+        temp = a[j];  // swapping a[j] & a[m]
+        a[j] = a[m];
+        a[m] = temp;
+    }
+    SlowSort(a, i, j - 1);
 }
 
-//Sample Main function
+// Sample Main function
 
-int main()
-{
-  int size;
-  cout << "\nEnter the number of elements : ";
+int main() {
+    int size;
+    cout << "\nEnter the number of elements : ";
 
-  cin >> size;
+    cin >> size;
 
-  int arr[size];
+    int *arr = new int[size];
 
-  cout << "\nEnter the unsorted elements : ";
+    cout << "\nEnter the unsorted elements : ";
 
-  for (int i = 0; i < size; ++i)
-  {
-    cout << "\n";
-    cin >> arr[i];
-  }
+    for (int i = 0; i < size; ++i) {
+        cout << "\n";
+        cin >> arr[i];
+    }
 
-  SlowSort(arr, 0, size);
+    SlowSort(arr, 0, size);
 
-  cout << "Sorted array\n";
+    cout << "Sorted array\n";
 
-  for (int i = 0; i < size; ++i)
-  {
-    cout << arr[i] << " ";
-  }
-  return 0;
+    for (int i = 0; i < size; ++i) {
+        cout << arr[i] << " ";
+    }
+    delete[] arr;
+    return 0;
 }
diff --git a/sorting/swap_sort.cpp b/sorting/swap_sort.cpp
index a4ab1e57b..2e59e2fb3 100644
--- a/sorting/swap_sort.cpp
+++ b/sorting/swap_sort.cpp
@@ -10,7 +10,7 @@ int minSwaps(int arr[], int n) {
     // Create an array of pairs where first
     // element is array element and second element
     // is position of first element
-    std::pair<int, int> arrPos[n];
+    std::pair<int, int> *arrPos = new std::pair<int, int>[n];
     for (int i = 0; i < n; i++) {
         arrPos[i].first = arr[i];
         arrPos[i].second = i;
@@ -32,8 +32,7 @@ int minSwaps(int arr[], int n) {
     for (int i = 0; i < n; i++) {
         // already swapped and corrected or
         // already present at correct pos
-        if (vis[i] || arrPos[i].second == i)
-            continue;
+        if (vis[i] || arrPos[i].second == i) continue;
 
         // find out the number of node in
         // this cycle and add in ans
@@ -53,6 +52,8 @@ int minSwaps(int arr[], int n) {
         }
     }
 
+    delete[] arrPos;
+
     // Return result
     return ans;
 }
diff --git a/sorting/tim_sort.cpp b/sorting/tim_sort.cpp
index 14d3a04d0..94f5aa230 100644
--- a/sorting/tim_sort.cpp
+++ b/sorting/tim_sort.cpp
@@ -1,115 +1,103 @@
 // C++ program to perform TimSort.
+#include <algorithm>
 #include <iostream>
-using namespace std;
+
 const int RUN = 32;
- 
-// this function sorts array from left index to to right index which is of size atmost RUN
-void insertionSort(int arr[], int left, int right)
-{
-    for (int i = left + 1; i <= right; i++)
-    {
+
+// this function sorts array from left index to to right index which is of size
+// atmost RUN
+void insertionSort(int arr[], int left, int right) {
+    for (int i = left + 1; i <= right; i++) {
         int temp = arr[i];
         int j = i - 1;
-        while (arr[j] > temp && j >= left)
-        {
-            arr[j+1] = arr[j];
+        while (arr[j] > temp && j >= left) {
+            arr[j + 1] = arr[j];
             j--;
         }
-        arr[j+1] = temp;
+        arr[j + 1] = temp;
     }
 }
- 
+
 // merge function merges the sorted runs
-void merge(int arr[], int l, int m, int r)
-{
+void merge(int arr[], int l, int m, int r) {
     // original array is broken in two parts, left and right array
     int len1 = m - l + 1, len2 = r - m;
-    int left[len1], right[len2];
-    for (int i = 0; i < len1; i++)
-        left[i] = arr[l + i];
-    for (int i = 0; i < len2; i++)
-        right[i] = arr[m + 1 + i];
- 
+    int *left = new int[len1], *right = new int[len2];
+    for (int i = 0; i < len1; i++) left[i] = arr[l + i];
+    for (int i = 0; i < len2; i++) right[i] = arr[m + 1 + i];
+
     int i = 0;
     int j = 0;
     int k = l;
- 
+
     // after comparing, we merge those two array in larger sub array
-    while (i < len1 && j < len2)
-    {
-        if (left[i] <= right[j])
-        {
+    while (i < len1 && j < len2) {
+        if (left[i] <= right[j]) {
             arr[k] = left[i];
             i++;
-        }
-        else
-        {
+        } else {
             arr[k] = right[j];
             j++;
         }
         k++;
     }
- 
+
     // copy remaining elements of left, if any
-    while (i < len1)
-    {
+    while (i < len1) {
         arr[k] = left[i];
         k++;
         i++;
     }
- 
+
     // copy remaining element of right, if any
-    while (j < len2)
-    {
+    while (j < len2) {
         arr[k] = right[j];
         k++;
         j++;
     }
+    delete[] left;
+    delete[] right;
 }
- 
+
 // iterative Timsort function to sort the array[0...n-1] (similar to merge sort)
-void timSort(int arr[], int n)
-{
+void timSort(int arr[], int n) {
     // Sort individual subarrays of size RUN
-    for (int i = 0; i < n; i+=RUN)
-        insertionSort(arr, i, min((i+31), (n-1)));
- 
-    // start merging from size RUN (or 32). It will merge to form size 64, then 128, 256 and so on ....
-    for (int size = RUN; size < n; size = 2*size)
-    {
-        // pick starting point of left sub array. We are going to merge arr[left..left+size-1] and arr[left+size, left+2*size-1]
-        // After every merge, we increase left by 2*size
-        for (int left = 0; left < n; left += 2*size)
-        {
+    for (int i = 0; i < n; i += RUN)
+        insertionSort(arr, i, std::min((i + 31), (n - 1)));
+
+    // start merging from size RUN (or 32). It will merge to form size 64, then
+    // 128, 256 and so on ....
+    for (int size = RUN; size < n; size = 2 * size) {
+        // pick starting point of left sub array. We are going to merge
+        // arr[left..left+size-1] and arr[left+size, left+2*size-1] After every
+        // merge, we increase left by 2*size
+        for (int left = 0; left < n; left += 2 * size) {
             // find ending point of left sub array
             // mid+1 is starting point of right sub array
             int mid = left + size - 1;
-            int right = min((left + 2*size - 1), (n-1));
- 
+            int right = std::min((left + 2 * size - 1), (n - 1));
+
             // merge sub array arr[left.....mid] & arr[mid+1....right]
             merge(arr, left, mid, right);
         }
     }
 }
- 
+
 // utility function to print the Array
-void printArray(int arr[], int n)
-{
-    for (int i = 0; i < n; i++)
-        printf("%d  ", arr[i]);
-    printf("\n");
+void printArray(int arr[], int n) {
+    for (int i = 0; i < n; i++) printf("%d  ", arr[i]);
+    std::cout << std::endl;
 }
- 
+
 // Driver program to test above function
-int main()
-{
+int main() {
     int arr[] = {5, 21, 7, 23, 19};
-    int n = sizeof(arr)/sizeof(arr[0]);
+    int n = sizeof(arr) / sizeof(arr[0]);
     printf("Given Array is\n");
     printArray(arr, n);
- 
+
     timSort(arr, n);
- 
+
     printf("After Sorting Array is\n");
     printArray(arr, n);
     return 0;

From d3acc554c6b5f7ffa1a12ffb49d0323d852a3c20 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:07:14 -0400
Subject: [PATCH 102/290] cpplint issues fixed in sorting folder

(cherry picked from commit 35c53760d34bc483ba737706937985346bf39fd8)
---
 sorting/radix_sort.cpp |  2 +-
 sorting/slow_sort.cpp  | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/sorting/radix_sort.cpp b/sorting/radix_sort.cpp
index e5bc3db84..a0fbfe99e 100644
--- a/sorting/radix_sort.cpp
+++ b/sorting/radix_sort.cpp
@@ -55,4 +55,4 @@ int main(int argc, char const* argv[]) {
     radixsort(a, n);
     print(a, n);
     return 0;
-}
\ No newline at end of file
+}
diff --git a/sorting/slow_sort.cpp b/sorting/slow_sort.cpp
index 2872b37d8..b2627d12f 100644
--- a/sorting/slow_sort.cpp
+++ b/sorting/slow_sort.cpp
@@ -9,7 +9,6 @@
 // while being slow, must still all the time be working towards a result.
 
 #include <iostream>
-using namespace std;
 
 void SlowSort(int a[], int i, int j) {
     if (i >= j) return;
@@ -30,26 +29,27 @@ void SlowSort(int a[], int i, int j) {
 
 int main() {
     int size;
-    cout << "\nEnter the number of elements : ";
+    std::cout << "\nEnter the number of elements : ";
 
-    cin >> size;
+    std::cin >> size;
 
     int *arr = new int[size];
 
-    cout << "\nEnter the unsorted elements : ";
+    std::cout << "\nEnter the unsorted elements : ";
 
     for (int i = 0; i < size; ++i) {
-        cout << "\n";
-        cin >> arr[i];
+        std::cout << "\n";
+        std::cin >> arr[i];
     }
 
     SlowSort(arr, 0, size);
 
-    cout << "Sorted array\n";
+    std::cout << "Sorted array\n";
 
     for (int i = 0; i < size; ++i) {
-        cout << arr[i] << " ";
+        std::cout << arr[i] << " ";
     }
+
     delete[] arr;
     return 0;
 }

From 6e6f92e7739526bda9772c0edcc433b01062fac3 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 17:33:50 +0000
Subject: [PATCH 103/290] updating DIRECTORY.md

---
 DIRECTORY.md | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 47842b9ca..9a336c1a5 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -179,29 +179,29 @@
   * [Ternary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/ternary_search.cpp)
 
 ## Sorting
-  * [Beadsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/BeadSort.cpp)
-  * [Bitonicsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/BitonicSort.cpp)
-  * [Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Bubble%20Sort.cpp)
-  * [Bucketsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bucketSort.cpp)
-  * [Cocktailselectionsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/CocktailSelectionSort.cpp)
-  * [Combsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/combsort.cpp)
+  * [Bead Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bead_sort.cpp)
+  * [Bitonic Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bitonic_sort.cpp)
+  * [Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bubble_sort.cpp)
+  * [Bucket Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bucket_sort.cpp)
+  * [Cocktail Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/cocktail_selection_sort.cpp)
+  * [Comb Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/comb_sort.cpp)
   * [Counting Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Counting_Sort.cpp)
-  * [Countingsortstring](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/CountingSortString.cpp)
+  * [Counting Sort String](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/counting_sort_string.cpp)
   * [Heap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/heap_sort.cpp)
-  * [Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Insertion%20Sort.cpp)
+  * [Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/insertion_sort.cpp)
   * [Library Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/library_sort.cpp)
-  * [Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Merge%20Sort.cpp)
+  * [Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/merge_sort.cpp)
   * [Non Recursive Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/non_recursive_merge_sort.cpp)
-  * [Numericstringsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/NumericStringSort.cpp)
-  * [Oddeven Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/OddEven%20Sort.cpp)
-  * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Quick%20Sort.cpp)
-  * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Radix%20Sort.cpp)
-  * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Selection%20Sort.cpp)
-  * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Shell%20Sort.cpp)
+  * [Numeric String Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/numeric_string_sort.cpp)
+  * [Odd Even Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/odd_even_sort.cpp)
+  * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort.cpp)
+  * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort.cpp)
+  * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort.cpp)
+  * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort.cpp)
   * [Shell Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort2.cpp)
-  * [Slow Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Slow%20Sort.cpp)
+  * [Slow Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/slow_sort.cpp)
   * [Swap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/swap_sort.cpp)
-  * [Tim Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Tim%20Sort.cpp)
+  * [Tim Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/tim_sort.cpp)
 
 ## Strings
   * [Brute Force String Searching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/strings/brute_force_string_searching.cpp)

From 07ebe713b01d26bd32b0dc1c8965459e7837f390 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 13:41:11 -0400
Subject: [PATCH 104/290] added deleted files back - not really needed but
 there is a redundant github action that required it

---
 sorting/doxy.txt | 374 +++++++++++++++++++++++++++++++++++++++++++++++
 sorting/makefile |  11 ++
 2 files changed, 385 insertions(+)
 create mode 100644 sorting/doxy.txt
 create mode 100644 sorting/makefile

diff --git a/sorting/doxy.txt b/sorting/doxy.txt
new file mode 100644
index 000000000..68079276e
--- /dev/null
+++ b/sorting/doxy.txt
@@ -0,0 +1,374 @@
+# Doxyfile 1.8.13
+#This configuration file has been generated from Doxygen template.
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = "My Project"
+PROJECT_NUMBER         =
+PROJECT_BRIEF          =
+PROJECT_LOGO           =
+OUTPUT_DIRECTORY       =
+CREATE_SUBDIRS         = NO
+ALLOW_UNICODE_NAMES    = NO
+OUTPUT_LANGUAGE        = English
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        =
+STRIP_FROM_INC_PATH    =
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = NO
+QT_AUTOBRIEF           = NO
+MULTILINE_CPP_IS_BRIEF = NO
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 4
+ALIASES                =
+TCL_SUBST              =
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+OPTIMIZE_FOR_FORTRAN   = NO
+OPTIMIZE_OUTPUT_VHDL   = NO
+EXTENSION_MAPPING      =
+MARKDOWN_SUPPORT       = YES
+TOC_INCLUDE_HEADINGS   = 0
+AUTOLINK_SUPPORT       = YES
+BUILTIN_STL_SUPPORT    = NO
+CPP_CLI_SUPPORT        = NO
+SIP_SUPPORT            = NO
+IDL_PROPERTY_SUPPORT   = YES
+DISTRIBUTE_GROUP_DOC   = NO
+GROUP_NESTED_COMPOUNDS = NO
+SUBGROUPING            = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS  = NO
+TYPEDEF_HIDES_STRUCT   = NO
+LOOKUP_CACHE_SIZE      = 0
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_PACKAGE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+EXTRACT_ANON_NSPACES   = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+HIDE_COMPOUND_REFERENCE= NO
+SHOW_INCLUDE_FILES     = YES
+SHOW_GROUPED_MEMB_INC  = NO
+FORCE_LOCAL_INCLUDES   = NO
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+SORT_BRIEF_DOCS        = NO
+SORT_MEMBERS_CTORS_1ST = NO
+SORT_GROUP_NAMES       = NO
+SORT_BY_SCOPE_NAME     = NO
+STRICT_PROTO_MATCHING  = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       =
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_FILES             = YES
+SHOW_NAMESPACES        = YES
+FILE_VERSION_FILTER    =
+LAYOUT_FILE            =
+CITE_BIB_FILES         =
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_AS_ERROR          = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           =
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  =
+INPUT_ENCODING         = UTF-8
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.idl \
+                         *.ddl \
+                         *.odl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.cs \
+                         *.d \
+                         *.php \
+                         *.php4 \
+                         *.php5 \
+                         *.phtml \
+                         *.inc \
+                         *.m \
+                         *.markdown \
+                         *.md \
+                         *.mm \
+                         *.dox \
+                         *.py \
+                         *.pyw \
+                         *.f90 \
+                         *.f95 \
+                         *.f03 \
+                         *.f08 \
+                         *.f \
+                         *.for \
+                         *.tcl \
+                         *.vhd \
+                         *.vhdl \
+                         *.ucf \
+                         *.qsf
+RECURSIVE              = NO
+EXCLUDE                =
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       =
+EXCLUDE_SYMBOLS        =
+EXAMPLE_PATH           =
+EXAMPLE_PATTERNS       = *
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             =
+INPUT_FILTER           =
+FILTER_PATTERNS        =
+FILTER_SOURCE_FILES    = NO
+FILTER_SOURCE_PATTERNS =
+USE_MDFILE_AS_MAINPAGE =
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+REFERENCES_LINK_SOURCE = YES
+SOURCE_TOOLTIPS        = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = YES
+CLANG_ASSISTED_PARSING = NO
+CLANG_OPTIONS          =
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          =
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            =
+HTML_FOOTER            =
+HTML_STYLESHEET        =
+HTML_EXTRA_STYLESHEET  =
+HTML_EXTRA_FILES       =
+HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_GAMMA  = 80
+HTML_TIMESTAMP         = NO
+HTML_DYNAMIC_SECTIONS  = NO
+HTML_INDEX_NUM_ENTRIES = 100
+GENERATE_DOCSET        = NO
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME  = Publisher
+GENERATE_HTMLHELP      = NO
+CHM_FILE               =
+HHC_LOCATION           =
+GENERATE_CHI           = NO
+CHM_INDEX_ENCODING     =
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+GENERATE_QHP           = NO
+QCH_FILE               =
+QHP_NAMESPACE          = org.doxygen.Project
+QHP_VIRTUAL_FOLDER     = doc
+QHP_CUST_FILTER_NAME   =
+QHP_CUST_FILTER_ATTRS  =
+QHP_SECT_FILTER_ATTRS  =
+QHG_LOCATION           =
+GENERATE_ECLIPSEHELP   = NO
+ECLIPSE_DOC_ID         = org.doxygen.Project
+DISABLE_INDEX          = NO
+GENERATE_TREEVIEW      = NO
+ENUM_VALUES_PER_LINE   = 4
+TREEVIEW_WIDTH         = 250
+EXT_LINKS_IN_WINDOW    = NO
+FORMULA_FONTSIZE       = 10
+FORMULA_TRANSPARENT    = YES
+USE_MATHJAX            = NO
+MATHJAX_FORMAT         = HTML-CSS
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_EXTENSIONS     =
+MATHJAX_CODEFILE       =
+SEARCHENGINE           = YES
+SERVER_BASED_SEARCH    = NO
+EXTERNAL_SEARCH        = NO
+SEARCHENGINE_URL       =
+SEARCHDATA_FILE        = searchdata.xml
+EXTERNAL_SEARCH_ID     =
+EXTRA_SEARCH_MAPPINGS  =
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4
+EXTRA_PACKAGES         =
+LATEX_HEADER           =
+LATEX_FOOTER           =
+LATEX_EXTRA_STYLESHEET =
+LATEX_EXTRA_FILES      =
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = YES
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+LATEX_SOURCE_CODE      = NO
+LATEX_BIB_STYLE        = plain
+LATEX_TIMESTAMP        = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    =
+RTF_EXTENSIONS_FILE    =
+RTF_SOURCE_CODE        = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_SUBDIR             =
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_PROGRAMLISTING     = YES
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+GENERATE_DOCBOOK       = NO
+DOCBOOK_OUTPUT         = docbook
+DOCBOOK_PROGRAMLISTING = NO
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           =
+INCLUDE_FILE_PATTERNS  =
+PREDEFINED             =
+EXPAND_AS_DEFINED      =
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+TAGFILES               =
+GENERATE_TAGFILE       =
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+EXTERNAL_PAGES         = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+MSCGEN_PATH            =
+DIA_PATH               =
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = YES
+DOT_NUM_THREADS        = 0
+DOT_FONTNAME           = Helvetica
+DOT_FONTSIZE           = 10
+DOT_FONTPATH           =
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = NO
+UML_LIMIT_NUM_FIELDS   = 10
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+INTERACTIVE_SVG        = NO
+DOT_PATH               =
+DOTFILE_DIRS           =
+MSCFILE_DIRS           =
+DIAFILE_DIRS           =
+PLANTUML_JAR_PATH      =
+PLANTUML_CFG_FILE      =
+PLANTUML_INCLUDE_PATH  =
+DOT_GRAPH_MAX_NODES    = 50
+MAX_DOT_GRAPH_DEPTH    = 0
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
diff --git a/sorting/makefile b/sorting/makefile
new file mode 100644
index 000000000..21d3186c6
--- /dev/null
+++ b/sorting/makefile
@@ -0,0 +1,11 @@
+non_recursive_merge_sort: non_recursive_merge_sort.cpp
+	g++ -std=c++17 -o non_recursive_merge_sort non_recursive_merge_sort.cpp
+.PHONY: test
+.PHONY: doc
+.PHONY: clean
+test: non_recursive_merge_sort
+	./non_recursive_merge_sort
+doc: doxy.txt
+	doxygen doxy.txt
+clean:
+	rm -fr non_recursive_merge_sort html

From 286ca5c5106cc8b7620a3da6f73c006363caf626 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Tue, 26 May 2020 16:40:09 -0400
Subject: [PATCH 105/290] include  search folder in cmake

---
 CMakeLists.txt                                |   2 +
 search/CMakeLists.txt                         |  18 +++
 search/Linear Search.cpp                      |  47 ------
 search/exponential_search.cpp                 |  63 ++++----
 ...n Search.cpp => interpolation_search2.cpp} |  23 ++-
 search/jump_search.cpp                        |  35 ++---
 search/linear_search.cpp                      |  39 +++++
 search/median_search.cpp                      | 101 ++++++-------
 search/searching.cpp                          |  52 +++----
 search/ternary_search.cpp                     | 141 ++++++++----------
 10 files changed, 250 insertions(+), 271 deletions(-)
 create mode 100644 search/CMakeLists.txt
 delete mode 100644 search/Linear Search.cpp
 rename search/{Interpolation Search.cpp => interpolation_search2.cpp} (50%)
 create mode 100644 search/linear_search.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f2940c962..aafeb69d3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,6 +24,7 @@ find_package(Doxygen OPTIONAL_COMPONENTS dot dia)
 if(DOXYGEN_FOUND)
     set(DOXYGEN_GENERATE_MAN NO)
     set(DOXYGEN_USE_MATHJAX YES)
+    set(DOXYGEN_FILE_PATTERNS *.cpp *.h *.hpp *.md)
     set(DOXYGEN_GENERATE_HTML YES)
     set(DOXYGEN_INLINE_SOURCES YES)
     set(DOXYGEN_CREATE_SUBDIRS YES)
@@ -50,6 +51,7 @@ endif()
 
 add_subdirectory(math)
 add_subdirectory(others)
+add_subdirectory(search)
 add_subdirectory(strings)
 add_subdirectory(sorting)
 add_subdirectory(computer_oriented_statistical_methods)
diff --git a/search/CMakeLists.txt b/search/CMakeLists.txt
new file mode 100644
index 000000000..5fd1ae591
--- /dev/null
+++ b/search/CMakeLists.txt
@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/search")
+
+endforeach( testsourcefile ${APP_SOURCES} )
diff --git a/search/Linear Search.cpp b/search/Linear Search.cpp
deleted file mode 100644
index 97e820437..000000000
--- a/search/Linear Search.cpp	
+++ /dev/null
@@ -1,47 +0,0 @@
-#include <iostream>
-using namespace std;
-
-int LinearSearch(int *array, int size, int key)
-{
-	for (int i = 0; i < size; ++i)
-	{
-		if (array[i] == key)
-		{
-			return i;
-		}
-	}
-
-	return -1;
-}
-
-int main()
-{
-	int size;
-	cout << "\nEnter the size of the Array : ";
-	cin >> size;
-
-	int array[size];
-	int key;
-
-	//Input array
-	cout << "\nEnter the Array of " << size << " numbers : ";
-	for (int i = 0; i < size; i++)
-	{
-		cin >> array[i];
-	}
-
-	cout << "\nEnter the number to be searched : ";
-	cin >> key;
-
-	int index = LinearSearch(array, size, key);
-	if (index != -1)
-	{
-		cout << "\nNumber found at index : " << index;
-	}
-	else
-	{
-		cout << "\nNot found";
-	}
-
-	return 0;
-}
diff --git a/search/exponential_search.cpp b/search/exponential_search.cpp
index b8343fa02..5f9e64217 100644
--- a/search/exponential_search.cpp
+++ b/search/exponential_search.cpp
@@ -1,23 +1,28 @@
 // Copyright 2020 Divide-et-impera-11
-#include <assert.h>
+#include <cassert>
+#include <cmath>
 #include <iostream>
 #include <string>
-using namespaces std;
+
 // Binary Search Algorithm(use by struzik algorithm)
 // Time Complexity O(log n) where 'n' is the number of elements
 // Worst Time Complexity O(log n)
 // Best Time Complexity Ω(1)
 // Space Complexity O(1)
 // Auxiliary Space Complexity O(1)
-template<class Type> inline Type* binary_s(Type *array, size_t size, Type key) {
-int32_t lower_index(0), upper_index(size - 1), middle_index;
-while (lower_index <= upper_index) {
-     middle_index = floor((lower_index + upper_index) / 2);
-     if (*(array + middle_index) < key) lower_index = (middle_index + 1);
-     else if (*(array + middle_index) > key)upper_index = (middle_index - 1);
-     else  return (array + middle_index);
-     }
-return nullptr;
+template <class Type>
+inline Type* binary_s(Type* array, size_t size, Type key) {
+    int32_t lower_index(0), upper_index(size - 1), middle_index;
+    while (lower_index <= upper_index) {
+        middle_index = std::floor((lower_index + upper_index) / 2);
+        if (*(array + middle_index) < key)
+            lower_index = (middle_index + 1);
+        else if (*(array + middle_index) > key)
+            upper_index = (middle_index - 1);
+        else
+            return (array + middle_index);
+    }
+    return nullptr;
 }
 // Struzik Search Algorithm(Exponential)
 // Time Complexity O(log i)where i is the position of search key in the list
@@ -32,25 +37,27 @@ If the key is larger than the last element of array,
 the start of block(block_front) will be equal to the end of block(block_size)
 and the algorithm return null ponter,
 every other cases the algoritm return fom the loop. */
-template<class Type> Type* struzik_search(Type* array, size_t size, Type key) {
-  uint32_t block_front(0), block_size = size == 0 ? 0 : 1;
-  while (block_front != block_size) {
+template <class Type>
+Type* struzik_search(Type* array, size_t size, Type key) {
+    uint32_t block_front(0), block_size = size == 0 ? 0 : 1;
+    while (block_front != block_size) {
         if (*(array + block_size - 1) < key) {
-           block_front = block_size;
-           (block_size * 2 - 1 < size) ? (block_size *= 2) : block_size = size;
-           continue;
+            block_front = block_size;
+            (block_size * 2 - 1 < size) ? (block_size *= 2) : block_size = size;
+            continue;
         }
-  return binary_s<Type>(array + block_front, (block_size - block_front), key);
-  }
-return nullptr;
+        return binary_s<Type>(array + block_front, (block_size - block_front),
+                              key);
+    }
+    return nullptr;
 }
 int main() {
-// TEST CASES
-int *sorted_array = new int[7]{7, 10, 15, 23, 70, 105, 203};
-assert(struzik_search<int>(sorted_array, 7, 0) == nullptr);
-assert(struzik_search<int>(sorted_array, 7, 1000) == nullptr);
-assert(struzik_search<int>(sorted_array, 7, 50) == nullptr);
-assert(struzik_search<int>(sorted_array, 7, 7) == sorted_array);
-// TEST CASES
-return 0;
+    // TEST CASES
+    int* sorted_array = new int[7]{7, 10, 15, 23, 70, 105, 203};
+    assert(struzik_search<int>(sorted_array, 7, 0) == nullptr);
+    assert(struzik_search<int>(sorted_array, 7, 1000) == nullptr);
+    assert(struzik_search<int>(sorted_array, 7, 50) == nullptr);
+    assert(struzik_search<int>(sorted_array, 7, 7) == sorted_array);
+    // TEST CASES
+    return 0;
 }
diff --git a/search/Interpolation Search.cpp b/search/interpolation_search2.cpp
similarity index 50%
rename from search/Interpolation Search.cpp
rename to search/interpolation_search2.cpp
index f52ce4f4f..0e6d3b79d 100644
--- a/search/Interpolation Search.cpp	
+++ b/search/interpolation_search2.cpp
@@ -1,31 +1,30 @@
 #include <iostream>
-int InterpolationSearch(int A[], int n, int x)
-{
+int InterpolationSearch(int A[], int n, int x) {
     int low = 0;
     int high = n - 1;
-    while (low <= high)
-    {
+    while (low <= high) {
         int mid = low + (((high - 1) * (x - A[low])) / (A[high] - A[low]));
         if (x == A[mid])
-            return mid; // Found x, return (exit)
+            return mid;  // Found x, return (exit)
         else if (x < A[mid])
-            high = mid - 1; // X lies before mid
+            high = mid - 1;  // X lies before mid
         else
-            low = mid + 1; // x lies after mid
+            low = mid + 1;  // x lies after mid
     }
     return -1;
 }
 
-int main()
-{
+int main() {
     int A[] = {2, 4, 5, 7, 13, 14, 15, 23};
     int x = 17;
-    int index = InterpolationSearch(A, 8, x); // passed array A inside the InterpolationSearch function
+    int index = InterpolationSearch(
+        A, 8, x);  // passed array A inside the InterpolationSearch function
     if (index != -1)
         std::cout << "Number " << x << " is at " << index;
     else
         std::cout << "Number " << x << " not found";
 }
 
-// randomly set x bcoz array was defined by us , therefore not reasonable for asking input.
-// We could have asked for input if array elements were inputed by the user.
+// randomly set x bcoz array was defined by us , therefore not reasonable for
+// asking input. We could have asked for input if array elements were inputed by
+// the user.
diff --git a/search/jump_search.cpp b/search/jump_search.cpp
index 0ee7e4e00..aa2ee0bdb 100644
--- a/search/jump_search.cpp
+++ b/search/jump_search.cpp
@@ -1,47 +1,40 @@
 // C++ program to implement Jump Search
 
-#include <bits/stdc++.h>
-using namespace std;
+#include <algorithm>
+#include <cmath>
+#include <iostream>
 
-int jumpSearch(int arr[], int x, int n)
-{
+int jumpSearch(int arr[], int x, int n) {
     // Finding block size to be jumped
-    int step = sqrt(n);
+    int step = std::sqrt(n);
 
     // Finding the block where element is
     // present (if it is present)
     int prev = 0;
-    while (arr[min(step, n)-1] < x)
-    {
+    while (arr[std::min(step, n) - 1] < x) {
         prev = step;
-        step += sqrt(n);
-        if (prev >= n)
-            return -1;
+        step += std::sqrt(n);
+        if (prev >= n) return -1;
     }
 
     // Doing a linear search for x in block
     // beginning with prev.
-    while (arr[prev] < x)
-    {
+    while (arr[prev] < x) {
         prev++;
 
         // If we reached next block or end of
         // array, element is not present.
-        if (prev == min(step, n))
-            return -1;
+        if (prev == std::min(step, n)) return -1;
     }
     // If element is found
-    if (arr[prev] == x)
-        return prev;
+    if (arr[prev] == x) return prev;
 
     return -1;
 }
 
 // Driver program to test function
-int main()
-{
-    int arr[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21,
-                34, 55, 89, 144, 233, 377, 610 };
+int main() {
+    int arr[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610};
     int x = 55;
     int n = sizeof(arr) / sizeof(arr[0]);
 
@@ -49,6 +42,6 @@ int main()
     int index = jumpSearch(arr, x, n);
 
     // Print the index where 'x' is located
-    cout << "\nNumber " << x << " is at index " << index;
+    std::cout << "\nNumber " << x << " is at index " << index;
     return 0;
 }
diff --git a/search/linear_search.cpp b/search/linear_search.cpp
new file mode 100644
index 000000000..8849549e5
--- /dev/null
+++ b/search/linear_search.cpp
@@ -0,0 +1,39 @@
+#include <iostream>
+
+int LinearSearch(int *array, int size, int key) {
+    for (int i = 0; i < size; ++i) {
+        if (array[i] == key) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+int main() {
+    int size;
+    std::cout << "\nEnter the size of the Array : ";
+    std::cin >> size;
+
+    int *array = new int[size];
+    int key;
+
+    // Input array
+    std::cout << "\nEnter the Array of " << size << " numbers : ";
+    for (int i = 0; i < size; i++) {
+        std::cin >> array[i];
+    }
+
+    std::cout << "\nEnter the number to be searched : ";
+    std::cin >> key;
+
+    int index = LinearSearch(array, size, key);
+    if (index != -1) {
+        std::cout << "\nNumber found at index : " << index;
+    } else {
+        std::cout << "\nNot found";
+    }
+
+    delete[] array;
+    return 0;
+}
diff --git a/search/median_search.cpp b/search/median_search.cpp
index be95b599f..fa8ef3826 100644
--- a/search/median_search.cpp
+++ b/search/median_search.cpp
@@ -1,72 +1,57 @@
-#include<iostream>
-#include<math.h>
-#include<deque>
-#include<stack>
-#include<vector>
-#include<algorithm>
-#include<iterator>
-using namespace std;
-vector<int>v;
-vector<int>s1;
-vector<int>s2;
-vector<int>s3;
+#include <algorithm>
+#include <cmath>
+#include <deque>
+#include <iostream>
+#include <iterator>
+#include <stack>
+#include <vector>
+
+std::vector<int> v;
+std::vector<int> s1;
+std::vector<int> s2;
+std::vector<int> s3;
+
 template <class X>
-void comp(X x)
-{
-    if(s1.size()>=x && s1.size()+s2.size()<x)
-    {
-        cout<<s2[0]<<" is the "<<x+1<<"th element from front";
-    }
-    else if(s1.size()>x)
-    {
-        sort(s1.begin(),s1.end());
-        cout<<s1[x]<<" is the "<<x+1<<"th element from front";
-    }
-    else if(s1.size()+s2.size()<=x && s3.size()>x)
-    {
-        sort(s3.begin(),s3.end());
-        cout<<s3[x-s1.size()-s2.size()]<<" is the "<<x+1<<"th element from front";
-    }
-    else
-    {
-        cout<<x+1<<" is invalid location";
+void comp(X x) {
+    if (s1.size() >= x && s1.size() + s2.size() < x) {
+        std::cout << s2[0] << " is the " << x + 1 << "th element from front";
+    } else if (s1.size() > x) {
+        std::sort(s1.begin(), s1.end());
+        std::cout << s1[x] << " is the " << x + 1 << "th element from front";
+    } else if (s1.size() + s2.size() <= x && s3.size() > x) {
+        std::sort(s3.begin(), s3.end());
+        std::cout << s3[x - s1.size() - s2.size()] << " is the " << x + 1
+                  << "th element from front";
+    } else {
+        std::cout << x + 1 << " is invalid location";
     }
 }
-int main()
-{
-    for(int i=0;i<1000;i++)
-    {
-        v.push_back(rand()%1000);
+int main() {
+    for (int i = 0; i < 1000; i++) {
+        v.push_back(std::rand() % 1000);
     }
-    for(int r:v)
-    {
-        cout<<r<<" ";
+    for (int r : v) {
+        std::cout << r << " ";
     }
-    int median=rand()%1000;
-    cout<<"\nmedian="<<median<<endl;
-    int avg1,avg2,avg3,sum1=0,sum2=0,sum3=0;
-    for(int i=0;i<1000;i++)
-    {
-        if(v.back()==v[median])
-        {
-            avg1=sum1+v.back();
+    int median = std::rand() % 1000;
+    std::cout << "\nmedian=" << median << std::endl;
+    int avg1, avg2, avg3, sum1 = 0, sum2 = 0, sum3 = 0;
+    for (int i = 0; i < 1000; i++) {
+        if (v.back() == v[median]) {
+            avg1 = sum1 + v.back();
             s2.push_back(v.back());
-        }
-        else if(v.back()<v[median])
-        {
-            avg2=sum2+v.back();
+        } else if (v.back() < v[median]) {
+            avg2 = sum2 + v.back();
             s1.push_back(v.back());
-        }
-        else
-        {
-            avg3=sum3+v.back();
+        } else {
+            avg3 = sum3 + v.back();
             s3.push_back(v.back());
         }
         v.pop_back();
     }
     int x;
-    cout<<"enter the no. to be searched form begining:- ";
-    cin>>x;
-    comp(x-1);
+    std::cout << "enter the no. to be searched form begining:- ";
+    std::cin >> x;
+    comp(x - 1);
     return 0;
 }
diff --git a/search/searching.cpp b/search/searching.cpp
index 6a9dcac7d..d01619738 100644
--- a/search/searching.cpp
+++ b/search/searching.cpp
@@ -1,38 +1,32 @@
+#include <cstdlib>
 #include <iostream>
 #include <string>
-#include <cstdlib>
 
-using namespace std;
 char paragraph;
 
-int main()
-{
-    string paragraph;
-    cout << "Please enter your paragraph: \n";
-    getline(cin, paragraph);
-    cout << "\nHello, your paragraph is:\n " << paragraph << "!\n";
-    cout << "\nThe size of your paragraph = " << paragraph.size() << " characters. \n\n";
+int main() {
+    std::string paragraph;
+    std::cout << "Please enter your paragraph: \n";
+    std::getline(std::cin, paragraph);
+    std::cout << "\nHello, your paragraph is:\n " << paragraph << "!\n";
+    std::cout << "\nThe size of your paragraph = " << paragraph.size()
+              << " characters. \n\n";
 
-    if (paragraph.empty())
-    {
-        cout << "\nThe paragraph is empty" << endl;
-    }
-    else
-    {
-        while (true)
-        {
-            string word;
-            cout << "Please enter the word you are searching for: ";
-            getline(cin, word);
-            cout << "Hello, your word is " << word << "!\n";
-            if (paragraph.find(word) == string::npos)
-            {
-                cout << word << " does not exist in the sentence" << endl;
-            }
-            else
-            {
-                cout << "The word " << word << " is now found at location " << paragraph.find(word) << endl
-                     << endl;
+    if (paragraph.empty()) {
+        std::cout << "\nThe paragraph is empty" << std::endl;
+    } else {
+        while (true) {
+            std::string word;
+            std::cout << "Please enter the word you are searching for: ";
+            std::getline(std::cin, word);
+            std::cout << "Hello, your word is " << word << "!\n";
+            if (paragraph.find(word) == std::string::npos) {
+                std::cout << word << " does not exist in the sentence"
+                          << std::endl;
+            } else {
+                std::cout << "The word " << word << " is now found at location "
+                          << paragraph.find(word) << std::endl
+                          << std::endl;
             }
             system("pause");
         }
diff --git a/search/ternary_search.cpp b/search/ternary_search.cpp
index 4cb8d19d9..4d1918d48 100644
--- a/search/ternary_search.cpp
+++ b/search/ternary_search.cpp
@@ -3,16 +3,15 @@
  * It does this by dividing the search space by 3 parts and
  * using its property (usually monotonic property) to find
  * the desired index.
- * 
+ *
  * Time Complexity : O(log3 n)
  * Space Complexity : O(1) (without the array)
  */
 
 #include <iostream>
-using namespace std;
 
 /*
- * The absolutePrecision can be modified to fit preference but 
+ * The absolutePrecision can be modified to fit preference but
  * it is recommended to not go lower than 10 due to errors that
  * may occur.
  *
@@ -30,99 +29,89 @@ int A[MAX] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 10};
 /*
  * get_input function is to receive input from standard IO
  */
-void get_input()
-{
-  // TODO: Get input from STDIO or write input to memory as done above.
+void get_input() {
+    // TODO(christianbender): Get input from STDIO or write input to memory as
+    // done above.
 }
 
 /*
- * This is the iterative method of the ternary search which returns the index of the element.
+ * This is the iterative method of the ternary search which returns the index of
+ * the element.
  */
-int it_ternary_search(int left, int right, int A[], int target)
-{
-  while (1)
-  {
-    if (left < right)
-    {
-      if (right - left < absolutePrecision)
-      {
-        for (int i = left; i <= right; i++)
-          if (A[i] == target)
-            return i;
+int it_ternary_search(int left, int right, int A[], int target) {
+    while (1) {
+        if (left < right) {
+            if (right - left < absolutePrecision) {
+                for (int i = left; i <= right; i++)
+                    if (A[i] == target) return i;
 
-        return -1;
-      }
+                return -1;
+            }
 
-      int oneThird = (left + right) / 3 + 1;
-      int twoThird = (left + right) * 2 / 3 + 1;
+            int oneThird = (left + right) / 3 + 1;
+            int twoThird = (left + right) * 2 / 3 + 1;
 
-      if (A[oneThird] == target)
-        return oneThird;
-      else if (A[twoThird] == target)
-        return twoThird;
+            if (A[oneThird] == target)
+                return oneThird;
+            else if (A[twoThird] == target)
+                return twoThird;
 
-      else if (target > A[twoThird])
-        left = twoThird + 1;
-      else if (target < A[oneThird])
-        right = oneThird - 1;
+            else if (target > A[twoThird])
+                left = twoThird + 1;
+            else if (target < A[oneThird])
+                right = oneThird - 1;
 
-      else
-        left = oneThird + 1, right = twoThird - 1;
+            else
+                left = oneThird + 1, right = twoThird - 1;
+        } else {
+            return -1;
+        }
     }
-    else
-      return -1;
-  }
 }
 
-/* 
- * This is the recursive method of the ternary search which returns the index of the element.
+/*
+ * This is the recursive method of the ternary search which returns the index of
+ * the element.
  */
-int rec_ternary_search(int left, int right, int A[], int target)
-{
-  if (left < right)
-  {
-    if (right - left < absolutePrecision)
-    {
-      for (int i = left; i <= right; i++)
-        if (A[i] == target)
-          return i;
+int rec_ternary_search(int left, int right, int A[], int target) {
+    if (left < right) {
+        if (right - left < absolutePrecision) {
+            for (int i = left; i <= right; i++)
+                if (A[i] == target) return i;
 
-      return -1;
+            return -1;
+        }
+
+        int oneThird = (left + right) / 3 + 1;
+        int twoThird = (left + right) * 2 / 3 + 1;
+
+        if (A[oneThird] == target) return oneThird;
+        if (A[twoThird] == target) return twoThird;
+
+        if (target < A[oneThird])
+            return rec_ternary_search(left, oneThird - 1, A, target);
+        if (target > A[twoThird])
+            return rec_ternary_search(twoThird + 1, right, A, target);
+
+        return rec_ternary_search(oneThird + 1, twoThird - 1, A, target);
+    } else {
+        return -1;
     }
-
-    int oneThird = (left + right) / 3 + 1;
-    int twoThird = (left + right) * 2 / 3 + 1;
-
-    if (A[oneThird] == target)
-      return oneThird;
-    if (A[twoThird] == target)
-      return twoThird;
-
-    if (target < A[oneThird])
-      return rec_ternary_search(left, oneThird - 1, A, target);
-    if (target > A[twoThird])
-      return rec_ternary_search(twoThird + 1, right, A, target);
-
-    return rec_ternary_search(oneThird + 1, twoThird - 1, A, target);
-  }
-  else
-    return -1;
 }
 
 /*
  * ternary_search is a template function
- * You could either use it_ternary_search or rec_ternary_search according to preference.
+ * You could either use it_ternary_search or rec_ternary_search according to
+ * preference.
  */
-void ternary_search(int N, int A[], int target)
-{
-  cout << it_ternary_search(0, N - 1, A, target) << '\t';
-  cout << rec_ternary_search(0, N - 1, A, target) << '\t';
-  cout << '\n';
+void ternary_search(int N, int A[], int target) {
+    std::cout << it_ternary_search(0, N - 1, A, target) << '\t';
+    std::cout << rec_ternary_search(0, N - 1, A, target) << '\t';
+    std::cout << std::endl;
 }
 
-int main()
-{
-  get_input();
-  ternary_search(N, A, _target);
-  return 0;
+int main() {
+    get_input();
+    ternary_search(N, A, _target);
+    return 0;
 }

From 0aa566757ebdbd2e72af57a2fbfe51769bc2d6a6 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Tue, 26 May 2020 20:40:33 +0000
Subject: [PATCH 106/290] updating DIRECTORY.md

---
 DIRECTORY.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 9a336c1a5..ba455f2c1 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -170,10 +170,10 @@
   * [Binary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/binary_search.cpp)
   * [Exponential Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/exponential_search.cpp)
   * [Hash Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/hash_search.cpp)
-  * [Interpolation Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/Interpolation%20Search.cpp)
   * [Interpolation Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/interpolation_search.cpp)
+  * [Interpolation Search2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/interpolation_search2.cpp)
   * [Jump Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/jump_search.cpp)
-  * [Linear Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/Linear%20Search.cpp)
+  * [Linear Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/linear_search.cpp)
   * [Median Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/median_search.cpp)
   * [Searching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/searching.cpp)
   * [Ternary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/ternary_search.cpp)

From c892cbadc630bac45ea9ffbb2bada8a427187bba Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Tue, 26 May 2020 18:07:41 -0400
Subject: [PATCH 107/290] fixed code for lint and copy constructor

---
 others/fibonacci_large.cpp |   7 +-
 others/large_number.h      | 470 +++++++++++++++++++------------------
 2 files changed, 244 insertions(+), 233 deletions(-)

diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index 0333feb81..6f36702a2 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -18,11 +18,12 @@ large_number fib(uint64_t n) {
     large_number f1(1);
 
     do {
-        large_number f2 = f0 + f1;
-        f0 = f1;
-        f1 = f2;
+        large_number f2 = f1;
+        f1 += f0;
+        f0 = f2;
         n--;
     } while (n > 2);  // since we start from 2
+
     return f1;
 }
 
diff --git a/others/large_number.h b/others/large_number.h
index 38d9125de..8ea8190b6 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -1,4 +1,5 @@
 /**
+ * @file
  * @author Krishna Vedala
  * @email krishna (dot) vedala (at) ieee (dot) org
  **/
@@ -21,252 +22,261 @@
  **/
 class large_number {
  public:
-  /**< initializer with value = 1 */
-  large_number() { _digits.push_back(1); }
+    /**< initializer with value = 1 */
+    large_number() { _digits.push_back(1); }
 
-  /**< initializer from an integer */
-  explicit large_number(uint64_t n) {
-    uint64_t carry = n;
-    do {
-      add_digit(carry % 10);
-      carry /= 10;
-    } while (carry != 0);
-  }
+    // /**< initializer from an integer */
+    // explicit large_number(uint64_t n) {
+    //     uint64_t carry = n;
+    //     do {
+    //         add_digit(carry % 10);
+    //         carry /= 10;
+    //     } while (carry != 0);
+    // }
 
-  /**< initializer from another large_number */
-  explicit large_number(const large_number &a) { _digits = a._digits; }
-
-  /**< initializer from a vector */
-  explicit large_number(const std::vector<unsigned char> &vec) {
-    _digits = vec;
-  }
-
-  /**< initializer from a string */
-  explicit large_number(const char *number_str) {
-    for (size_t i = strlen(number_str); i > 0; i--) {
-      unsigned char a = number_str[i - 1] - '0';
-      if (a >= 0 && a <= 9) _digits.push_back(a);
-    }
-  }
-
-  /**
-   * Function to check implementation
-   **/
-  static bool test() {
-    std::cout << "------ Checking `large_number` class implementations\t"
-              << std::endl;
-    large_number a(40);
-    // 1. test multiplication
-    a *= 10;
-    if (a != large_number(400)) {
-      std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
-      return false;
-    }
-    std::cout << "\tPassed 1/6...";
-    // 2. test compound addition with integer
-    a += 120;
-    if (a != large_number(520)) {
-      std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
-      return false;
-    }
-    std::cout << "\tPassed 2/6...";
-    // 3. test compound multiplication again
-    a *= 10;
-    if (a != large_number(5200)) {
-      std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
-      return false;
-    }
-    std::cout << "\tPassed 3/6...";
-    // 4. test increment (prefix)
-    ++a;
-    if (a != large_number(5201)) {
-      std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
-      return false;
-    }
-    std::cout << "\tPassed 4/6...";
-    // 5. test increment (postfix)
-    a++;
-    if (a != large_number(5202)) {
-      std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
-      return false;
-    }
-    std::cout << "\tPassed 5/6...";
-    // 6. test addition with another large number
-    a = a + large_number("7000000000000000000000000000000");
-    if (a != large_number("7000000000000000000000000005202")) {
-      std::cerr << "\tFailed 6/6 (" << a << "!=7000000000000000000000000005202)"
-                << std::endl;
-      return false;
-    }
-    std::cout << "\tPassed 6/6..." << std::endl;
-    return true;
-  }
-
-  /**
-   * add a digit at MSB to the large number
-   **/
-  void add_digit(unsigned int value) {
-    if (value > 9) {
-      std::cerr << "digit > 9!!\n";
-      exit(EXIT_FAILURE);
+    /**< initializer from an integer */
+    explicit large_number(int n) {
+        int carry = n;
+        do {
+            add_digit(carry % 10);
+            carry /= 10;
+        } while (carry != 0);
     }
 
-    _digits.push_back(value);
-  }
+    /**< initializer from another large_number */
+    large_number(const large_number &a) : _digits(a._digits) {}
 
-  /**
-   * Get number of digits in the number
-   **/
-  const size_t num_digits() const { return _digits.size(); }
+    /**< initializer from a vector */
+    explicit large_number(std::vector<unsigned char> &vec) : _digits(vec) {}
 
-  /**
-   * operator over load to access the
-   * i^th digit conveniently and also
-   * assign value to it
-   **/
-  inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
-
-  inline const unsigned char &operator[](size_t n) const {
-    return this->_digits[n];
-  }
-
-  /**
-   * operator overload to compare two numbers
-   **/
-  friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
-    for (size_t i = a.num_digits(); i > 0; i--)
-      out << static_cast<int>(a[i - 1]);
-    return out;
-  }
-
-  /**
-   * operator overload to compare two numbers
-   **/
-  friend bool operator==(large_number const &a, large_number const &b) {
-    size_t N = a.num_digits();
-    if (N != b.num_digits()) return false;
-    for (size_t i = 0; i < N; i++)
-      if (a[i] != b[i]) return false;
-    return true;
-  }
-
-  /**
-   * operator overload to compare two numbers
-   **/
-  friend bool operator!=(large_number const &a, large_number const &b) {
-    return !(a == b);
-  }
-
-  /**
-   * operator overload to increment (prefix)
-   **/
-  large_number &operator++() {
-    (*this) += 1;
-    return *this;
-  }
-
-  /**
-   * operator overload to increment (postfix)
-   **/
-  large_number operator++(int) {
-    large_number tmp(_digits);
-    ++(*this);
-    return tmp;
-  }
-
-  /**
-   * operator overload to add
-   **/
-  template <class T>
-  large_number &operator+=(T n) {
-    // if adding with another large_number
-    if (typeid(T) == typeid(large_number)) {
-      large_number *b = static_cast<large_number *>(&n);
-      const size_t max_L = std::max(this->num_digits(), b->num_digits());
-      unsigned int carry = 0;
-      size_t i;
-      for (i = 0; i < max_L || carry != 0; i++) {
-        if (i < b->num_digits()) carry += (*b)[i];
-        if (i < this->num_digits()) carry += (*this)[i];
-        if (i < this->num_digits())
-          (*this)[i] = carry % 10;
-        else
-          this->add_digit(carry % 10);
-        carry /= 10;
-      }
-    } else if (std::is_integral<T>::value) {
-      return (*this) += large_number(n);
-    } else {
-      std::cerr << "Must be integer addition unsigned integer types."
-                << std::endl;
+    /**< initializer from a string */
+    explicit large_number(char const *number_str) {
+        for (size_t i = strlen(number_str); i > 0; i--) {
+            unsigned char a = number_str[i - 1] - '0';
+            if (a >= 0 && a <= 9) _digits.push_back(a);
+        }
     }
-    return *this;
-  }
 
-  /**
-   * operator overload to perform addition
-   **/
-  template <class T>
-  friend large_number &operator+(large_number &a, const T &b) {
-    a += b;
-    return a;
-  }
+    /**
+     * Function to check implementation
+     **/
+    static bool test() {
+        std::cout << "------ Checking `large_number` class implementations\t"
+                  << std::endl;
+        large_number a(40);
+        // 1. test multiplication
+        a *= 10;
+        if (a != large_number(400)) {
+            std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 1/6...";
+        // 2. test compound addition with integer
+        a += 120;
+        if (a != large_number(520)) {
+            std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 2/6...";
+        // 3. test compound multiplication again
+        a *= 10;
+        if (a != large_number(5200)) {
+            std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 3/6...";
+        // 4. test increment (prefix)
+        ++a;
+        if (a != large_number(5201)) {
+            std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 4/6...";
+        // 5. test increment (postfix)
+        a++;
+        if (a != large_number(5202)) {
+            std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 5/6...";
+        // 6. test addition with another large number
+        a = a + large_number("7000000000000000000000000000000");
+        if (a != large_number("7000000000000000000000000005202")) {
+            std::cerr << "\tFailed 6/6 (" << a
+                      << "!=7000000000000000000000000005202)" << std::endl;
+            return false;
+        }
+        std::cout << "\tPassed 6/6..." << std::endl;
+        return true;
+    }
 
-  /**
-   * assignment operator
-   **/
-  void operator=(const large_number &b) { _digits = b._digits; }
+    /**
+     * add a digit at MSB to the large number
+     **/
+    void add_digit(unsigned int value) {
+        if (value > 9) {
+            std::cerr << "digit > 9!!\n";
+            exit(EXIT_FAILURE);
+        }
 
-  /**
-   * operator overload to increment
-   **/
-  template <class T>
-  large_number &operator*=(const T n) {
-    static_assert(std::is_integral<T>::value,
-                  "Must be integer addition unsigned integer types.");
-    this->multiply(n);
-    return *this;
-  }
+        _digits.push_back(value);
+    }
 
-  /**
-   * returns i^th digit as an ASCII character
-   **/
-  const char digit_char(size_t i) const {
-    return _digits[num_digits() - i - 1] + '0';
-  }
+    /**
+     * Get number of digits in the number
+     **/
+    const size_t num_digits() const { return _digits.size(); }
+
+    /**
+     * operator over load to access the
+     * i^th digit conveniently and also
+     * assign value to it
+     **/
+    inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
+
+    inline const unsigned char &operator[](size_t n) const {
+        return this->_digits[n];
+    }
+
+    /**
+     * operator overload to compare two numbers
+     **/
+    friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
+        for (size_t i = a.num_digits(); i > 0; i--)
+            out << static_cast<int>(a[i - 1]);
+        return out;
+    }
+
+    /**
+     * operator overload to compare two numbers
+     **/
+    friend bool operator==(large_number const &a, large_number const &b) {
+        size_t N = a.num_digits();
+        if (N != b.num_digits()) return false;
+        for (size_t i = 0; i < N; i++)
+            if (a[i] != b[i]) return false;
+        return true;
+    }
+
+    /**
+     * operator overload to compare two numbers
+     **/
+    friend bool operator!=(large_number const &a, large_number const &b) {
+        return !(a == b);
+    }
+
+    /**
+     * operator overload to increment (prefix)
+     **/
+    large_number &operator++() {
+        (*this) += 1;
+        return *this;
+    }
+
+    /**
+     * operator overload to increment (postfix)
+     **/
+    large_number &operator++(int) {
+        large_number tmp(_digits);
+        ++(*this);
+        return tmp;
+    }
+
+    /**
+     * operator overload to add
+     **/
+    large_number &operator+=(large_number n) {
+        // if adding with another large_number
+        large_number *b = reinterpret_cast<large_number *>(&n);
+        const size_t max_L = std::max(this->num_digits(), b->num_digits());
+        unsigned int carry = 0;
+        size_t i;
+        for (i = 0; i < max_L || carry != 0; i++) {
+            if (i < b->num_digits()) carry += (*b)[i];
+            if (i < this->num_digits()) carry += (*this)[i];
+            if (i < this->num_digits())
+                (*this)[i] = carry % 10;
+            else
+                this->add_digit(carry % 10);
+            carry /= 10;
+        }
+        return *this;
+    }
+
+    large_number &operator+=(int n) { return (*this) += large_number(n); }
+    // large_number &operator+=(uint64_t n) { return (*this) += large_number(n);
+    // }
+
+    /**
+     * operator overload to perform addition
+     **/
+    template <class T>
+    friend large_number &operator+(const large_number &a, const T &b) {
+        large_number c = a;
+        c += b;
+        return c;
+    }
+
+    /**
+     * assignment operator
+     **/
+    large_number &operator=(const large_number &b) {
+        this->_digits = b._digits;
+        return *this;
+    }
+
+    /**
+     * operator overload to increment
+     **/
+    template <class T>
+    large_number &operator*=(const T n) {
+        static_assert(std::is_integral<T>::value,
+                      "Must be integer addition unsigned integer types.");
+        this->multiply(n);
+        return *this;
+    }
+
+    /**
+     * returns i^th digit as an ASCII character
+     **/
+    const char digit_char(size_t i) const {
+        return _digits[num_digits() - i - 1] + '0';
+    }
 
  private:
-  /**
-   * multiply large number with another integer and
-   * store the result in the same large number
-   **/
-  template <class T>
-  void multiply(const T n) {
-    static_assert(std::is_integral<T>::value, "Can only have integer types.");
-    // assert(!(std::is_signed<T>::value)); //, "Implemented only for
-    // unsigned integer types.");
+    /**
+     * multiply large number with another integer and
+     * store the result in the same large number
+     **/
+    template <class T>
+    void multiply(const T n) {
+        static_assert(std::is_integral<T>::value,
+                      "Can only have integer types.");
+        // assert(!(std::is_signed<T>::value)); //, "Implemented only for
+        // unsigned integer types.");
 
-    size_t i;
-    uint64_t carry = 0, temp;
-    for (i = 0; i < this->num_digits(); i++) {
-      temp = (*this)[i] * n;
-      temp += carry;
-      if (temp < 10) {
-        carry = 0;
-      } else {
-        carry = temp / 10;
-        temp = temp % 10;
-      }
-      (*this)[i] = temp;
+        size_t i;
+        uint64_t carry = 0, temp;
+        for (i = 0; i < this->num_digits(); i++) {
+            temp = (*this)[i] * n;
+            temp += carry;
+            if (temp < 10) {
+                carry = 0;
+            } else {
+                carry = temp / 10;
+                temp = temp % 10;
+            }
+            (*this)[i] = temp;
+        }
+
+        while (carry != 0) {
+            this->add_digit(carry % 10);
+            carry /= 10;
+        }
     }
 
-    while (carry != 0) {
-      this->add_digit(carry % 10);
-      carry /= 10;
-    }
-  }
-
-  std::vector<unsigned char> _digits; /**< where individual digits are stored */
+    std::vector<unsigned char>
+        _digits; /**< where individual digits are stored */
 };
 
 #endif  // OTHERS_LARGE_NUMBER_H_

From 77641f9b69b1f0e4b8e9988561ced94e5c343718 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Tue, 26 May 2020 18:15:00 -0400
Subject: [PATCH 108/290] use static variable to return reference for

---
 others/large_number.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/others/large_number.h b/others/large_number.h
index 8ea8190b6..544682987 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -177,7 +177,7 @@ class large_number {
      * operator overload to increment (postfix)
      **/
     large_number &operator++(int) {
-        large_number tmp(_digits);
+        static large_number tmp(_digits);
         ++(*this);
         return tmp;
     }
@@ -212,7 +212,7 @@ class large_number {
      **/
     template <class T>
     friend large_number &operator+(const large_number &a, const T &b) {
-        large_number c = a;
+        static large_number c = a;
         c += b;
         return c;
     }

From 030348a284415e04315b4ee865da47d7bce74fdd Mon Sep 17 00:00:00 2001
From: liushubin-gitHub <65377959+liushubin-gitHub@users.noreply.github.com>
Date: Wed, 27 May 2020 10:03:54 +0800
Subject: [PATCH 109/290] Update doubly_linked_list.cpp

when remove an item , should free the item memory
---
 data_structure/doubly_linked_list.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/data_structure/doubly_linked_list.cpp b/data_structure/doubly_linked_list.cpp
index 17ea2983a..4fc38abfc 100644
--- a/data_structure/doubly_linked_list.cpp
+++ b/data_structure/doubly_linked_list.cpp
@@ -61,6 +61,7 @@ void double_linked_list::remove(int x) {
     t->prev->next = t->next;
     t->next->prev = t->prev;
   }
+  delete t;
 }
 
 void double_linked_list::search(int x) {

From ee3547fafcbf48650b0ae6eb92fe6a9809bb2b93 Mon Sep 17 00:00:00 2001
From: Ayaan Khan <ayaankhan98@gmail.com>
Date: Wed, 27 May 2020 15:41:15 +0530
Subject: [PATCH 110/290] Correction : Fixed Array Overflow

---
 sorting/quick_sort.cpp | 61 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 sorting/quick_sort.cpp

diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
new file mode 100644
index 000000000..12ee66456
--- /dev/null
+++ b/sorting/quick_sort.cpp
@@ -0,0 +1,61 @@
+/*
+ *
+ *      copyright The Algorithms
+ *      Author - 
+ *      Correction - ayaankhan98
+ *
+ */
+
+#include <cstdlib>
+#include <iostream>
+
+int partition(int arr[], int low, int high) {
+    int pivot = arr[high];    // pivot
+    int i = (low - 1);        // Index of smaller element
+
+    for (int j = low; j < high; j++) {
+        // If current element is smaller than or
+        // equal to pivot
+        if (arr[j] <= pivot) {
+            i++;   // increment index of smaller element
+            int temp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = temp;
+        }
+    }
+    int temp = arr[i + 1];
+    arr[i + 1] = arr[high];
+    arr[high] = temp;
+    return (i + 1);
+}
+
+void quickSort(int arr[], int low, int high) {
+    if (low < high) {
+        int p = partition(arr, low, high);
+        quickSort(arr, low, p - 1);
+        quickSort(arr, p + 1, high);
+    }
+}
+
+void show(int arr[], int size) {
+    for (int i = 0; i < size; i++)
+        std::cout << arr[i] << " ";
+    std::cout << "\n";
+}
+
+// Driver program to test above functions
+
+int main() {
+    int size;
+    std::cout << "\nEnter the number of elements : ";
+    std::cin >> size;
+    int *arr = new int[size];
+    std::cout << "\nEnter the unsorted elements : ";
+    for (int i = 0; i < size; ++i) {
+      std::cin >> arr[i];
+    }
+    quickSort(arr, 0, size-1);
+    std::cout << "Sorted array : ";
+    show(arr, size);
+    return 0;
+}

From 1a37992c1e7e538c7ffbe02c8448ef1abbdc1ab4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 08:08:31 -0400
Subject: [PATCH 111/290] set 1 space for `private` and `public` keywords in
 cpp-classes

---
 .vscode/settings.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 4d291141b..0a257500b 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -64,7 +64,7 @@
           "valarray": "cpp",
           "algorithm": "cpp"
      },
-     "C_Cpp.clang_format_style": "{ BasedOnStyle: Google, UseTab: Never, IndentWidth: 4, TabWidth: 4, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 80, AccessModifierOffset: -4, NamespaceIndentation: All }",
+     "C_Cpp.clang_format_style": "{ BasedOnStyle: Google, UseTab: Never, IndentWidth: 4, TabWidth: 4, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 80, AccessModifierOffset: -3, NamespaceIndentation: All }",
      "editor.formatOnSave": true,
      "editor.formatOnType": true,
      "editor.formatOnPaste": true

From d86ff19d44ad919abb3f4cb64d9431300f5dded8 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Wed, 27 May 2020 12:14:45 +0000
Subject: [PATCH 112/290] updating DIRECTORY.md

---
 DIRECTORY.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 9e36309dc..636543a25 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -197,6 +197,7 @@
   * [Numericstringsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/NumericStringSort.cpp)
   * [Oddeven Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/OddEven%20Sort.cpp)
   * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Quick%20Sort.cpp)
+  * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort.cpp)
   * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Radix%20Sort.cpp)
   * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Selection%20Sort.cpp)
   * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Shell%20Sort.cpp)

From 334eb3df591cabf3d860bd0467b7bdd70ce157f9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 09:13:21 -0400
Subject: [PATCH 113/290] documetnation for binary_exponent.cpp

---
 math/binary_exponent.cpp | 59 ++++++++++++++++++++++++----------------
 1 file changed, 35 insertions(+), 24 deletions(-)

diff --git a/math/binary_exponent.cpp b/math/binary_exponent.cpp
index b4551da25..05e6f33f7 100644
--- a/math/binary_exponent.cpp
+++ b/math/binary_exponent.cpp
@@ -1,46 +1,57 @@
-/// C++ Program to find Binary Exponent Iteratively and Recursively.
-
-#include<iostream>
-/*
- * Calculate a^b in O(log(b)) by converting b to a binary number.
- * Binary exponentiation is also known as exponentiation by squaring.
- * NOTE : This is a far better approach compared to naive method which provide O(b) operations.
+/**
+ * @file
+ * @brief C++ Program to find Binary Exponent Iteratively and Recursively.
+ *
+ * Calculate \f$a^b\f$ in \f$O(\log(b))\f$ by converting \f$b\f$ to a
+ * binary number. Binary exponentiation is also known as exponentiation by
+ * squaring.
+ * @note This is a far better approach compared to naive method which
+ * provide \f$O(b)\f$ operations.
+ *
  * Example:
- * 10 in base 2 is 1010.
- * 2^10 = 2^(1010) = 2^8 * 2^2
- * 2^1 = 2
- * 2^2 = (2^1)^2 = 2^2 = 4
- * 2^4 = (2^2)^2 = 4^2 = 16
- * 2^8 = (2^4)^2 = 16^2 = 256
- * Hence to calculate 2^10 we only need to multiply 2^8 and 2^2 skipping 2^1 and 2^4.
-*/
+ * </br>10 in base 2 is 1010.
+ * \f{eqnarray*}{
+ * 2^{10_d} &=& 2^{1010_b} = 2^8 * 2^2\\
+ * 2^1 &=& 2\\
+ * 2^2 &=& (2^1)^2 = 2^2 = 4\\
+ * 2^4 &=& (2^2)^2 = 4^2 = 16\\
+ * 2^8 &=& (2^4)^2 = 16^2 = 256\\
+ * \f}
+ * Hence to calculate 2^10 we only need to multiply \f$2^8\f$ and \f$2^2\f$
+ * skipping \f$2^1\f$ and \f$2^4\f$.
+ */
 
-/// Recursive function to calculate exponent in O(log(n)) using binary exponent.
+#include <iostream>
+
+/// Recursive function to calculate exponent in \f$O(\log(n))\f$ using binary
+/// exponent.
 int binExpo(int a, int b) {
     if (b == 0) {
         return 1;
     }
-    int res = binExpo(a, b/2);
-    if (b%2) {
-        return res*res*a;
+    int res = binExpo(a, b / 2);
+    if (b % 2) {
+        return res * res * a;
     } else {
-        return res*res;
+        return res * res;
     }
 }
 
-/// Iterative function to calculate exponent in O(log(n)) using binary exponent.
+/// Iterative function to calculate exponent in \f$O(\log(n))\f$ using binary
+/// exponent.
 int binExpo_alt(int a, int b) {
     int res = 1;
     while (b > 0) {
-        if (b%2) {
-            res = res*a;
+        if (b % 2) {
+            res = res * a;
         }
-        a = a*a;
+        a = a * a;
         b /= 2;
     }
     return res;
 }
 
+/// Main function
 int main() {
     int a, b;
     /// Give two numbers a, b

From 4134c16f429be72eece8b1d176ed0790738d31b1 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 09:21:54 -0400
Subject: [PATCH 114/290] documentation for double_factorial

---
 math/double_factorial.cpp | 41 ++++++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 18 deletions(-)

diff --git a/math/double_factorial.cpp b/math/double_factorial.cpp
index 7b0d1d970..2b28a5d5a 100644
--- a/math/double_factorial.cpp
+++ b/math/double_factorial.cpp
@@ -1,28 +1,33 @@
-#include <iostream>
+/**
+ * @file
+ * Double factorial of a non-negative integer n, is defined as the product of
+ * all the integers from 1 to n that have the same parity (odd or even) as n.
+ * <br/>It is also called as semifactorial of a number and is denoted by `!!`
+ */
+
 #include <cassert>
+#include <iostream>
 
-/* Double factorial of a non-negative integer n, is defined as the product of 
-all the integers from 1 to n that have the same parity (odd or even) as n.
-It is also called as semifactorial of a number and is denoted by !! */
-
+/// Compute double factorial using iterative method
 uint64_t double_factorial_iterative(uint64_t n) {
-  uint64_t res = 1;
-  for ( uint64_t i = n; i >= 0; i -= 2 ) {
-    if (i == 0 || i == 1) return res;
-    res *= i;
-  }
+    uint64_t res = 1;
+    for (uint64_t i = n; i >= 0; i -= 2) {
+        if (i == 0 || i == 1) return res;
+        res *= i;
+    }
 }
 
-/* Recursion can be costly for large numbers */
-
+/// Compute double factorial using resursive method.
+//  <br/>Recursion can be costly for large numbers.
 uint64_t double_factorial_recursive(uint64_t n) {
-  if (n <= 1) return 1;
-  return n * double_factorial_recursive(n - 2);
+    if (n <= 1) return 1;
+    return n * double_factorial_recursive(n - 2);
 }
 
+/// main function
 int main() {
-  uint64_t n{};
-  std::cin >> n;
-  assert(n >= 0);
-  std::cout << double_factorial_iterative(n);
+    uint64_t n{};
+    std::cin >> n;
+    assert(n >= 0);
+    std::cout << double_factorial_iterative(n);
 }

From c2cde125dd8c9077a10c8a5b29dfd00933ec5adb Mon Sep 17 00:00:00 2001
From: Ayaan Khan <43348292+ayaankhan98@users.noreply.github.com>
Date: Wed, 27 May 2020 18:54:19 +0530
Subject: [PATCH 115/290] Added documentation (#802)

* Added documentation

* Added breif comments on functions

* modified comment block

* further improved comment blocks
---
 sorting/Quick Sort.cpp | 67 ------------------------------------------
 sorting/quick_sort.cpp | 38 ++++++++++++++++++++++--
 2 files changed, 35 insertions(+), 70 deletions(-)
 delete mode 100644 sorting/Quick Sort.cpp

diff --git a/sorting/Quick Sort.cpp b/sorting/Quick Sort.cpp
deleted file mode 100644
index 0b807898f..000000000
--- a/sorting/Quick Sort.cpp	
+++ /dev/null
@@ -1,67 +0,0 @@
-/* C implementation QuickSort */
-#include <iostream>
-using namespace std;
-
-int partition(int arr[], int low, int high)
-{
-    int pivot = arr[high]; // pivot
-    int i = (low - 1);     // Index of smaller element
-
-    for (int j = low; j < high; j++)
-    {
-        // If current element is smaller than or
-        // equal to pivot
-        if (arr[j] <= pivot)
-        {
-            i++; // increment index of smaller element
-            int temp = arr[i];
-            arr[i] = arr[j];
-            arr[j] = temp;
-        }
-    }
-    int temp = arr[i + 1];
-    arr[i + 1] = arr[high];
-    arr[high] = temp;
-    return (i + 1);
-}
-
-void quickSort(int arr[], int low, int high)
-{
-    if (low < high)
-    {
-
-        int p = partition(arr, low, high);
-
-        quickSort(arr, low, p - 1);
-        quickSort(arr, p + 1, high);
-    }
-}
-
-void show(int arr[], int size)
-{
-    for (int i = 0; i < size; i++)
-        cout << arr[i] << "\n";
-}
-
-// Driver program to test above functions
-int main()
-{
-    int size;
-    cout << "\nEnter the number of elements : ";
-
-    cin >> size;
-
-    int arr[size];
-
-    cout << "\nEnter the unsorted elements : ";
-
-    for (int i = 0; i < size; ++i)
-    {
-        cout << "\n";
-        cin >> arr[i];
-    }
-    quickSort(arr, 0, size);
-    cout << "Sorted array\n";
-    show(arr, size);
-    return 0;
-}
diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
index 12ee66456..d067fa068 100644
--- a/sorting/quick_sort.cpp
+++ b/sorting/quick_sort.cpp
@@ -1,16 +1,42 @@
-/*
+/**
  *
  *      copyright The Algorithms
  *      Author - 
  *      Correction - ayaankhan98
  *
+ * Implementation Details -
+ *      Quick Sort is a divide and conquer algorithm. It picks and element as
+ *      pivot and partition the given array around the picked pivot. There
+ *      are many different versions of quickSort that pick pivot in different
+ *      ways.
+ *
+ *      1. Always pick the first element as pivot
+ *      2. Always pick the last element as pivot (implemented below)
+ *      3. Pick a random element as pivot
+ *      4. Pick median as pivot
+ *
+ *      The key process in quickSort is partition(). Target of partition is,
+ *      given an array and an element x(say) of array as pivot, put x at it's
+ *      correct position in sorted array and put all smaller elements (samller
+ *      than x) before x, and put all greater elements (greater than x) after
+ *      x. All this should be done in linear time
+ *
  */
 
 #include <cstdlib>
 #include <iostream>
 
+/**
+ *      This function takes last element as pivot, places  
+ *      the pivot element at its correct position in sorted  
+ *      array, and places all smaller (smaller than pivot)  
+ *      to left of pivot and all greater elements to right  
+ *      of pivot 
+ *
+ */
+
 int partition(int arr[], int low, int high) {
-    int pivot = arr[high];    // pivot
+    int pivot = arr[high];    // taking the last element as pivot
     int i = (low - 1);        // Index of smaller element
 
     for (int j = low; j < high; j++) {
@@ -29,6 +55,12 @@ int partition(int arr[], int low, int high) {
     return (i + 1);
 }
 
+/** 
+ *      The main function that implements QuickSort  
+ *      arr[] --> Array to be sorted,  
+ *      low --> Starting index,  
+ *      high --> Ending index 
+*/
 void quickSort(int arr[], int low, int high) {
     if (low < high) {
         int p = partition(arr, low, high);
@@ -37,6 +69,7 @@ void quickSort(int arr[], int low, int high) {
     }
 }
 
+// prints the array after sorting
 void show(int arr[], int size) {
     for (int i = 0; i < size; i++)
         std::cout << arr[i] << " ";
@@ -44,7 +77,6 @@ void show(int arr[], int size) {
 }
 
 // Driver program to test above functions
-
 int main() {
     int size;
     std::cout << "\nEnter the number of elements : ";

From 5a54093484588b2a11e96b40dca22e3a0ee42e8a Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Wed, 27 May 2020 13:24:42 +0000
Subject: [PATCH 116/290] updating DIRECTORY.md

---
 DIRECTORY.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 636543a25..9fdf260a9 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -196,7 +196,6 @@
   * [Non Recursive Merge Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/non_recursive_merge_sort.cpp)
   * [Numericstringsort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/NumericStringSort.cpp)
   * [Oddeven Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/OddEven%20Sort.cpp)
-  * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Quick%20Sort.cpp)
   * [Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort.cpp)
   * [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Radix%20Sort.cpp)
   * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Selection%20Sort.cpp)

From 44f68e9a2e50275fce0d6a3e23ed5f15585c1ff5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 12:54:42 -0400
Subject: [PATCH 117/290] bug fix - no function return and invalid for loop
 termination check

---
 math/double_factorial.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/math/double_factorial.cpp b/math/double_factorial.cpp
index 2b28a5d5a..73a3d344a 100644
--- a/math/double_factorial.cpp
+++ b/math/double_factorial.cpp
@@ -11,10 +11,11 @@
 /// Compute double factorial using iterative method
 uint64_t double_factorial_iterative(uint64_t n) {
     uint64_t res = 1;
-    for (uint64_t i = n; i >= 0; i -= 2) {
+    for (uint64_t i = n;; i -= 2) {
         if (i == 0 || i == 1) return res;
         res *= i;
     }
+    return res;
 }
 
 /// Compute double factorial using resursive method.

From 50070774dd7cbf80e76bbf32f5f45c2cb3d8f24b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 12:55:03 -0400
Subject: [PATCH 118/290] fix documentation for double_factorial

---
 math/double_factorial.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/math/double_factorial.cpp b/math/double_factorial.cpp
index 73a3d344a..26b90f356 100644
--- a/math/double_factorial.cpp
+++ b/math/double_factorial.cpp
@@ -2,7 +2,8 @@
  * @file
  * Double factorial of a non-negative integer n, is defined as the product of
  * all the integers from 1 to n that have the same parity (odd or even) as n.
- * <br/>It is also called as semifactorial of a number and is denoted by `!!`
+ * <br/>It is also called as semifactorial of a number and is denoted by
+ * \f$n!!\f$
  */
 
 #include <cassert>
@@ -27,7 +28,7 @@ uint64_t double_factorial_recursive(uint64_t n) {
 
 /// main function
 int main() {
-    uint64_t n{};
+    uint64_t n;
     std::cin >> n;
     assert(n >= 0);
     std::cout << double_factorial_iterative(n);

From d723604e0162c5f828d9f3137f1ff9c7f26e97ed Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 14:07:05 -0400
Subject: [PATCH 119/290] documentation update for double_factorial

---
 math/double_factorial.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/math/double_factorial.cpp b/math/double_factorial.cpp
index 26b90f356..37bd2052a 100644
--- a/math/double_factorial.cpp
+++ b/math/double_factorial.cpp
@@ -1,5 +1,7 @@
 /**
  * @file
+ * @brief Compute double factorial: \f$n!!\f$
+ *
  * Double factorial of a non-negative integer n, is defined as the product of
  * all the integers from 1 to n that have the same parity (odd or even) as n.
  * <br/>It is also called as semifactorial of a number and is denoted by
@@ -9,7 +11,8 @@
 #include <cassert>
 #include <iostream>
 
-/// Compute double factorial using iterative method
+/** Compute double factorial using iterative method
+ */
 uint64_t double_factorial_iterative(uint64_t n) {
     uint64_t res = 1;
     for (uint64_t i = n;; i -= 2) {
@@ -19,8 +22,9 @@ uint64_t double_factorial_iterative(uint64_t n) {
     return res;
 }
 
-/// Compute double factorial using resursive method.
-//  <br/>Recursion can be costly for large numbers.
+/** Compute double factorial using resursive method.
+ * <br/>Recursion can be costly for large numbers.
+ */
 uint64_t double_factorial_recursive(uint64_t n) {
     if (n <= 1) return 1;
     return n * double_factorial_recursive(n - 2);

From 4944d4c8b1dc00231209d24f26374dfc96d2c429 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 14:07:18 -0400
Subject: [PATCH 120/290] documentation for eulers_totient_function.cpp

---
 math/eulers_totient_function.cpp | 62 ++++++++++++++++++++------------
 1 file changed, 39 insertions(+), 23 deletions(-)

diff --git a/math/eulers_totient_function.cpp b/math/eulers_totient_function.cpp
index 31ced5a51..e7f6fbf7f 100644
--- a/math/eulers_totient_function.cpp
+++ b/math/eulers_totient_function.cpp
@@ -1,28 +1,37 @@
-/// C++ Program to find Euler Totient Function
-#include<iostream>
-
-/*
+/**
+ * @file
+ * @brief C++ Program to find
+ * [Euler's Totient](https://en.wikipedia.org/wiki/Euler%27s_totient_function)
+ * function
+ *
  * Euler Totient Function is also known as phi function.
- * phi(n) = phi(p1^a1).phi(p2^a2)...
- * where p1, p2,... are prime factors of n.
- * 3 Euler's properties:
- * 1. phi(prime_no) = prime_no-1
- * 2. phi(prime_no^k) = (prime_no^k - prime_no^(k-1))
- * 3. phi(a,b) = phi(a). phi(b) where a and b are relative primes.
+ * \f[\phi(n) =
+ * \phi\left({p_1}^{a_1}\right)\cdot\phi\left({p_2}^{a_2}\right)\ldots\f] where
+ * \f$p_1\f$, \f$p_2\f$, \f$\ldots\f$ are prime factors of n.
+ * <br/>3 Euler's properties:
+ * 1. \f$\phi(n) = n-1\f$
+ * 2. \f$\phi(n^k) = n^k - n^{k-1}\f$
+ * 3. \f$\phi(a,b) = \phi(a)\cdot\phi(b)\f$ where a and b are relative primes.
+ *
  * Applying this 3 properties on the first equation.
- * phi(n) = n. (1-1/p1). (1-1/p2). ...
- * where p1,p2... are prime factors.
- * Hence Implementation in O(sqrt(n)).
- * phi(100) = 40
- * phi(1) = 1
- * phi(17501) = 15120
- * phi(1420) = 560
+ * \f[\phi(n) =
+ * n\cdot\left(1-\frac{1}{p_1}\right)\cdot\left(1-\frac{1}{p_2}\right)\cdots\f]
+ * where \f$p_1\f$,\f$p_2\f$... are prime factors.
+ * Hence Implementation in \f$O\left(\sqrt{n}\right)\f$.
+ * <br/>Some known values are:
+ * * \f$\phi(100) = 40\f$
+ * * \f$\phi(1) = 1\f$
+ * * \f$\phi(17501) = 15120\f$
+ * * \f$\phi(1420) = 560\f$
  */
+#include <cstdlib>
+#include <iostream>
 
-// Function to caculate Euler's totient phi
-int phiFunction(int n) {
-    int result = n;
-    for (int i = 2; i * i <= n; i++) {
+/** Function to caculate Euler's totient phi
+ */
+uint64_t phiFunction(uint64_t n) {
+    uint64_t result = n;
+    for (uint64_t i = 2; i * i <= n; i++) {
         if (n % i == 0) {
             while (n % i == 0) {
                 n /= i;
@@ -34,8 +43,15 @@ int phiFunction(int n) {
     return result;
 }
 
-int main() {
-    int n;
+/// Main function
+int main(int argc, char *argv[]) {
+    uint64_t n;
+    if (argc < 2) {
+        std::cout << "Enter the number: ";
+    } else {
+        n = strtoull(argv[1], nullptr, 10);
+    }
     std::cin >> n;
     std::cout << phiFunction(n);
+    return 0;
 }

From 691cbdb1f514f5bbd295b97c5d8123f63a9e62fe Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 15:06:36 -0400
Subject: [PATCH 121/290] fix code for generic types

---
 math/extended_euclid_algorithm.cpp | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/math/extended_euclid_algorithm.cpp b/math/extended_euclid_algorithm.cpp
index 3db14802f..829db4336 100644
--- a/math/extended_euclid_algorithm.cpp
+++ b/math/extended_euclid_algorithm.cpp
@@ -4,25 +4,27 @@
 // This is also used in finding Modular multiplicative inverse of a number.
 // (A * B)%M == 1 Here B is the MMI of A for given M,
 // so extendedEuclid (A, M) gives B.
+template <typename T, typename T2>
+void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
+    if (B > A) std::swap(A, B);  // Ensure that A >= B
 
-int d, x, y;
-void extendedEuclid(int A, int B) {
     if (B == 0) {
-        d = A;
-        x = 1;
-        y = 0;
+        *GCD = A;
+        *x = 1;
+        *y = 0;
     } else {
-        extendedEuclid(B, A%B);
-        int temp = x;
-        x = y;
-        y = temp - (A/B)*y;
+        extendedEuclid(B, A % B, GCD, x, y);
+        T2 temp = *x;
+        *x = *y;
+        *y = temp - (A / B) * (*y);
     }
 }
 
 int main() {
-    int a, b;
+    uint32_t a, b, gcd;
+    int32_t x, y;
     std::cin >> a >> b;
-    extendedEuclid(a, b);
-    std::cout << x << " " << y << std::endl;
+    extendedEuclid(a, b, &gcd, &x, &y);
+    std::cout << gcd << " " << x << " " << y << std::endl;
     return 0;
 }

From 757970dbaec023fd9cdcbab40fb64f66cae21bb5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 15:06:46 -0400
Subject: [PATCH 122/290] documentation for extended euclid

---
 math/extended_euclid_algorithm.cpp | 74 ++++++++++++++++++++++++++++--
 1 file changed, 69 insertions(+), 5 deletions(-)

diff --git a/math/extended_euclid_algorithm.cpp b/math/extended_euclid_algorithm.cpp
index 829db4336..84dec55c5 100644
--- a/math/extended_euclid_algorithm.cpp
+++ b/math/extended_euclid_algorithm.cpp
@@ -1,9 +1,70 @@
+/**
+ * @file
+ * @brief GCD using [extended Euclid's algorithm]
+ * (https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm)
+ *
+ * Finding coefficients of a and b ie x and y in  Bézout's identity
+ * \f[\text{gcd}(a, b) = a \times x + b \times y \f]
+ * This is also used in finding Modular
+ * multiplicative inverse of a number. (A * B)%M == 1 Here B is the MMI of A for
+ * given M, so extendedEuclid (A, M) gives B.
+ */
+#include <algorithm>  // for swap function
 #include <iostream>
-// Finding coefficients of a and b ie x and y in gcd(a, b) = a * x + b * y
-// d is gcd(a, b)
-// This is also used in finding Modular multiplicative inverse of a number.
-// (A * B)%M == 1 Here B is the MMI of A for given M,
-// so extendedEuclid (A, M) gives B.
+
+/**
+ * function to update the coefficients per iteration
+ * \f[r_0,\,r = r,\, r_0 - \text{quotient}\times r\f]
+ *
+ * @param[in,out] r signed
+ * @param[in,out] r0 signed
+ * @param[in] quotient  unsigned input
+ */
+template <typename T, typename T2>
+inline void update_step(T &r, T &r0, const T2 quotient) {
+    T temp = r;
+    r = r0 - (quotient * temp);
+    r0 = temp;
+}
+
+/**
+ * Implementation using iterative algorithm from
+ * [Wikipedia](https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm#Pseudocode)
+ *
+ * @param[in] A unsigned
+ * @param[in] B unsigned
+ * @param[out] GCD unsigned
+ * @param[out] x signed
+ * @param[out] y signed
+ */
+template <typename T1, typename T2>
+void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y) {
+    if (B > A) std::swap(A, B);  // Ensure that A >= B
+
+    T2 s = 0, s0 = 1;
+    T2 t = 1, t0 = 0;
+    T1 r = B, r0 = A;
+
+    while (r != 0) {
+        T1 quotient = r0 / r;
+        update_step(r, r0, quotient);
+        update_step(s, s0, quotient);
+        update_step(t, t0, quotient);
+    }
+    *GCD = r0;
+    *x = s0;
+    *y = t0;
+}
+
+/**
+ * Implementation using recursive algorithm
+ *
+ * @param[in] A unsigned
+ * @param[in] B unsigned
+ * @param[out] GCD unsigned
+ * @param[in,out] x signed
+ * @param[in,out] y signed
+ */
 template <typename T, typename T2>
 void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
     if (B > A) std::swap(A, B);  // Ensure that A >= B
@@ -20,11 +81,14 @@ void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
     }
 }
 
+/// Main function
 int main() {
     uint32_t a, b, gcd;
     int32_t x, y;
     std::cin >> a >> b;
     extendedEuclid(a, b, &gcd, &x, &y);
     std::cout << gcd << " " << x << " " << y << std::endl;
+    extendedEuclid_1(a, b, &gcd, &x, &y);
+    std::cout << gcd << " " << x << " " << y << std::endl;
     return 0;
 }

From d26206549248998e1dc1de57a271d3c931c44019 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 15:14:30 -0400
Subject: [PATCH 123/290] use template based functions

---
 math/fast_power.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index 0ffbcd40d..f69a90e4c 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -21,16 +21,17 @@
 /**
  * algorithm implementation for \f$a^b\f$
  */
-double fast_power_recursive(int64_t a, int64_t b) {
+template <typename T>
+double fast_power_recursive(T a, T b) {
     // negative power. a^b = 1 / (a^-b)
     if (b < 0) return 1.0 / fast_power_recursive(a, -b);
 
     if (b == 0) return 1;
-    int64_t bottom = fast_power_recursive(a, b >> 1);
+    T bottom = fast_power_recursive(a, b >> 1);
     // Since it is integer division b/2 = (b-1)/2 where b is odd.
     // Therefore, case2 is easily solved by integer division.
 
-    int64_t result;
+    double result;
     if ((b & 1) == 0)  // case1
         result = bottom * bottom;
     else  // case2
@@ -42,7 +43,8 @@ double fast_power_recursive(int64_t a, int64_t b) {
     Same algorithm with little different formula.
     It still calculates in O(logN)
 */
-double fast_power_linear(int64_t a, int64_t b) {
+template <typename T>
+double fast_power_linear(T a, T b) {
     // negative power. a^b = 1 / (a^-b)
     if (b < 0) return 1.0 / fast_power_linear(a, -b);
 

From a436cd7a1b3050af91f8aa4fdb6e5ec24b1d181d Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 15:14:39 -0400
Subject: [PATCH 124/290] improve documentation for fast_power

---
 math/fast_power.cpp | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index f69a90e4c..d4de07460 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -1,15 +1,16 @@
 /**
  * @file
-    Program that computes \f$a^b\f$ in \f$O(logN)\f$ time.
-    It is based on formula that:
-    1. if \f$b\f$ is even: \f$a^b = a^\frac{b}{2} \cdot a^\frac{b}{2} =
- {a^\frac{b}{2}}^2\f$
-    2. if \f$b\f$ is odd: \f$a^b = a^\frac{b-1}{2} \cdot
- a^\frac{b-1}{2} \cdot a = {a^\frac{b-1}{2}}^2 \cdot a\f$
-
- We can compute \f$a^b\f$
- recursively using above algorithm.
-*/
+ * @brief Faster computation for \f$a^b\f$
+ *
+ * Program that computes \f$a^b\f$ in \f$O(logN)\f$ time.
+ * It is based on formula that:
+ * 1. if \f$b\f$ is even:
+ *  \f$a^b = a^\frac{b}{2} \cdot a^\frac{b}{2} = {a^\frac{b}{2}}^2\f$
+ * 2. if \f$b\f$ is odd: \f$a^b = a^\frac{b-1}{2}
+ *  \cdot a^\frac{b-1}{2} \cdot a = {a^\frac{b-1}{2}}^2 \cdot a\f$
+ *
+ * We can compute \f$a^b\f$ recursively using above algorithm.
+ */
 
 #include <cassert>
 #include <cmath>
@@ -41,7 +42,7 @@ double fast_power_recursive(T a, T b) {
 
 /**
     Same algorithm with little different formula.
-    It still calculates in O(logN)
+    It still calculates in \f$O(\log N)\f$
 */
 template <typename T>
 double fast_power_linear(T a, T b) {
@@ -57,6 +58,9 @@ double fast_power_linear(T a, T b) {
     return result;
 }
 
+/**
+ * Main function
+ */
 int main() {
     std::srand(std::time(nullptr));
     std::ios_base::sync_with_stdio(false);

From e31ee6e83332e9c6e508e8bd88f216ce6042d40f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 15:42:12 -0400
Subject: [PATCH 125/290] better document GCD programs

---
 ...lidean.cpp => gcd_iterative_euclidean.cpp} | 18 +++++--
 math/gcd_recursive_euclidean.cpp              | 48 +++++++++++++++++++
 math/greatest_common_divisor.cpp              | 27 -----------
 3 files changed, 62 insertions(+), 31 deletions(-)
 rename math/{greatest_common_divisor_euclidean.cpp => gcd_iterative_euclidean.cpp} (80%)
 create mode 100644 math/gcd_recursive_euclidean.cpp
 delete mode 100644 math/greatest_common_divisor.cpp

diff --git a/math/greatest_common_divisor_euclidean.cpp b/math/gcd_iterative_euclidean.cpp
similarity index 80%
rename from math/greatest_common_divisor_euclidean.cpp
rename to math/gcd_iterative_euclidean.cpp
index c4812e45b..61fb640a3 100644
--- a/math/greatest_common_divisor_euclidean.cpp
+++ b/math/gcd_iterative_euclidean.cpp
@@ -1,10 +1,17 @@
-#include <cmath>
+/**
+ * @file
+ * @brief Compute the greatest common denominator of two integers using
+ * *iterative form* of
+ * [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm)
+ *
+ * @see gcd_recursive_euclidean.cpp
+ */
 #include <iostream>
 #include <stdexcept>
 
-// will find the greatest common denominator of two ints integers
-// Euclidean algorithm can be found here
-// https://en.wikipedia.org/wiki/Euclidean_algorithm
+/**
+ * algorithm
+ */
 int gcd(int num1, int num2) {
     if (num1 <= 0 | num2 <= 0) {
         throw std::domain_error("Euclidean algorithm domain is for ints > 0");
@@ -34,6 +41,9 @@ int gcd(int num1, int num2) {
     return previous_remainder;
 }
 
+/**
+ * Main function
+ */
 int main() {
     std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
     try {
diff --git a/math/gcd_recursive_euclidean.cpp b/math/gcd_recursive_euclidean.cpp
new file mode 100644
index 000000000..3a1ca6e66
--- /dev/null
+++ b/math/gcd_recursive_euclidean.cpp
@@ -0,0 +1,48 @@
+/**
+ * @file
+ * @brief Compute the greatest common denominator of two integers using
+ * *recursive form* of
+ * [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm)
+ *
+ * @see gcd_iterative_euclidean.cpp
+ */
+#include <iostream>
+
+/**
+ * algorithm
+ */
+int gcd(int num1, int num2) {
+    if (num1 <= 0 | num2 <= 0) {
+        throw std::domain_error("Euclidean algorithm domain is for ints > 0");
+    }
+
+    if (num1 == num2) {
+        return num1;
+    }
+
+    // Everything divides 0
+    if (num1 == 0) return num2;
+    if (num2 == 0) return num1;
+
+    // base case
+    if (num1 == num2) return num1;
+
+    // a is greater
+    if (num1 > num2) return gcd(num1 - num2, num2);
+    return gcd(num1, num2 - num1);
+}
+
+/**
+ * Main function
+ */
+int main() {
+    std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
+    try {
+        std::cout << "gcd of -120,10 is " << gcd(-120, 10) << std::endl;
+    } catch (const std::domain_error &e) {
+        std::cout << "Error handling was successful" << std::endl;
+    }
+    std::cout << "gcd of 312,221 is " << (gcd(312, 221)) << std::endl;
+    std::cout << "gcd of 289,204 is " << (gcd(289, 204)) << std::endl;
+    return 0;
+}
diff --git a/math/greatest_common_divisor.cpp b/math/greatest_common_divisor.cpp
deleted file mode 100644
index 5601c4be9..000000000
--- a/math/greatest_common_divisor.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// C++ program to find GCD of two numbers
-#include <iostream>
-
-// Recursive function to return gcd of a and b
-int gcd(int a, int b) {
-    // Everything divides 0
-    if (a == 0)
-       return b;
-    if (b == 0)
-       return a;
-
-    // base case
-    if (a == b)
-        return a;
-
-    // a is greater
-    if (a > b)
-        return gcd(a-b, b);
-    return gcd(a, b-a);
-}
-
-// Driver program to test above function
-int main() {
-    int a = 98, b = 56;
-    std::cout << "GCD of " << a << " and " << b << " is " << gcd(a, b);
-    return 0;
-}

From 49fe1b11ef124c240b5552b57d1b2ddbefcea5a5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 15:42:23 -0400
Subject: [PATCH 126/290] document fibonacci program

---
 math/fibonacci.cpp | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index e82875da3..1a5f4afb4 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -1,12 +1,17 @@
+/**
+ * @file
+ * @brief Generate fibonacci sequence
+ *
+ * Calculate the the value on Fibonacci's sequence given an
+ * integer as input.
+ * \f[\text{fib}(n) = \text{fib}(n-1) + \text{fib}(n-2)\f]
+ */
 #include <cassert>
 #include <iostream>
 
-/* Calculate the the value on Fibonacci's sequence given an
-integer as input
-Fibonacci =  0, 1, 1, 2, 3, 5,
-             8, 13, 21, 34, 55,
-             89, 144, ...       */
-
+/**
+ * Recursively compute sequences
+ */
 int fibonacci(unsigned int n) {
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
@@ -16,6 +21,7 @@ int fibonacci(unsigned int n) {
     return fibonacci(n - 1) + fibonacci(n - 2);
 }
 
+/// Main function
 int main() {
     int n;
     std::cin >> n;

From 4d272210fc8bd9c26f68abb4124edd5c3d509419 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Wed, 27 May 2020 19:42:57 +0000
Subject: [PATCH 127/290] updating DIRECTORY.md

---
 DIRECTORY.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index ba455f2c1..2b73144b8 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -109,8 +109,8 @@
   * [Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/factorial.cpp)
   * [Fast Power](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fast_power.cpp)
   * [Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci.cpp)
-  * [Greatest Common Divisor](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/greatest_common_divisor.cpp)
-  * [Greatest Common Divisor Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/greatest_common_divisor_euclidean.cpp)
+  * [Gcd Iterative Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_iterative_euclidean.cpp)
+  * [Gcd Recursive Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_recursive_euclidean.cpp)
   * [Modular Inverse Fermat Little Theorem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/modular_inverse_fermat_little_theorem.cpp)
   * [Number Of Positive Divisors](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/number_of_positive_divisors.cpp)
   * [Power For Huge Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/power_for_huge_numbers.cpp)

From 6173a6a7017553805c7e3cb05af42cae6147af58 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 16:09:50 -0400
Subject: [PATCH 128/290] documentation for Little Fermat's Thm

---
 .../modular_inverse_fermat_little_theorem.cpp | 81 ++++++++++++-------
 1 file changed, 50 insertions(+), 31 deletions(-)

diff --git a/math/modular_inverse_fermat_little_theorem.cpp b/math/modular_inverse_fermat_little_theorem.cpp
index 965c21298..7550e14bf 100644
--- a/math/modular_inverse_fermat_little_theorem.cpp
+++ b/math/modular_inverse_fermat_little_theorem.cpp
@@ -1,44 +1,59 @@
-/*
- * C++ Program to find the modular inverse using Fermat's Little Theorem.
- * Fermat's Little Theorem state that => ϕ(m) = m-1, where m is a prime number.
- *
- * (a * x) ≡ 1 mod m.
- * x ≡ (a^(-1)) mod m.
+/**
+ * @file
+ * @brief C++ Program to find the modular inverse using [Fermat's Little
+ * Theorem](https://en.wikipedia.org/wiki/Fermat%27s_little_theorem)
  *
+ * Fermat's Little Theorem state that \f[ϕ(m) = m-1\f]
+ * where \f$m\f$ is a prime number.
+ * \f{eqnarray*}{
+ *  a \cdot x &≡& 1 \;\text{mod}\; m\\
+ *  x &≡& a^{-1} \;\text{mod}\; m
+ * \f}
  * Using Euler's theorem we can modify the equation.
+ *\f[
+ * a^{ϕ(m)} ≡ 1 \;\text{mod}\; m
+ * \f]
+ * (Where '^' denotes the exponent operator)
  *
- * (a^ϕ(m)) ≡ 1 mod m (Where '^' denotes the exponent operator)
- * Here 'ϕ' is Euler's Totient Function. For modular inverse existence 'a' and 'm' must be relatively primes numbers.
- * To apply Fermat's Little Theorem is necessary that 'm' must be a prime number.
- * Generally in many competitive programming competitions 'm' is either 1000000007 (1e9+7) or 998244353.
+ * Here 'ϕ' is Euler's Totient Function. For modular inverse existence 'a' and
+ * 'm' must be relatively primes numbers. To apply Fermat's Little Theorem is
+ * necessary that 'm' must be a prime number. Generally in many competitive
+ * programming competitions 'm' is either 1000000007 (1e9+7) or 998244353.
  *
  * We considered m as large prime (1e9+7).
- * (a^ϕ(m)) ≡ 1 mod m (Using Euler's Theorem)
- * ϕ(m) = m-1 using Fermat's Little Theorem.
- * (a^(m-1)) ≡ 1 mod m
- * Now multiplying both side by (a^(-1)).
- * (a^(m-1)) * (a^(-1)) ≡  (a^(-1)) mod m
- * (a^(m-2)) ≡  (a^(-1)) mod m
+ * \f$a^{ϕ(m)} ≡ 1 \;\text{mod}\; m\f$ (Using Euler's Theorem)
+ * \f$ϕ(m) = m-1\f$ using Fermat's Little Theorem.
+ * \f$a^{m-1} ≡ 1 \;\text{mod}\; m\f$
+ * Now multiplying both side by \f$a^{-1}\f$.
+ * \f{eqnarray*}{
+ * a^{m-1} \cdot a^{-1} &≡& a^{-1} \;\text{mod}\; m\\
+ * a^{m-2} &≡&  a^{-1} \;\text{mod}\; m
+ * \f}
  *
- * We will find the exponent using binary exponentiation. Such that the algorithm works in O(log(m)) time.
+ * We will find the exponent using binary exponentiation. Such that the
+ * algorithm works in \f$O(\log m)\f$ time.
  *
- * Example: -
- * a = 3 and m = 7
- * (a^(-1) mod m) is equivalent to (a^(m-2) mod m)
- * (3^(5) mod 7) = (243 mod 7) = 5
- * Hence, ( 3^(-1) mod 7 ) = 5
- * or ( 3 * 5 ) mod 7 = 1 mod 7 (as a*(a^(-1)) = 1)
+ * Examples: -
+ * * a = 3 and m = 7
+ * * \f$a^{-1} \;\text{mod}\; m\f$ is equivalent to
+ * \f$a^{m-2} \;\text{mod}\; m\f$
+ * * \f$3^5 \;\text{mod}\; 7 = 243 \;\text{mod}\; 7 = 5\f$
+ * <br/>Hence, \f$3^{-1} \;\text{mod}\; 7 = 5\f$
+ * or \f$3 \times 5  \;\text{mod}\; 7 = 1 \;\text{mod}\; 7\f$
+ * (as \f$a\times a^{-1} = 1\f$)
  */
 
-#include<iostream>
-#include<vector>
+#include <iostream>
+#include <vector>
 
-// Recursive function to calculate exponent in O(log(n)) using binary exponent.
+/** Recursive function to calculate exponent in \f$O(\log n)\f$ using binary
+ * exponent.
+ */
 int64_t binExpo(int64_t a, int64_t b, int64_t m) {
     a %= m;
     int64_t res = 1;
     while (b > 0) {
-        if (b%2) {
+        if (b % 2) {
             res = res * a % m;
         }
         a = a * a % m;
@@ -48,13 +63,14 @@ int64_t binExpo(int64_t a, int64_t b, int64_t m) {
     return res;
 }
 
-// Prime check in O(sqrt(m)) time.
+/** Prime check in \f$O(\sqrt{m})\f$ time.
+ */
 bool isPrime(int64_t m) {
     if (m <= 1) {
         return false;
     } else {
-        for (int i=2; i*i <= m; i++) {
-            if (m%i == 0) {
+        for (int64_t i = 2; i * i <= m; i++) {
+            if (m % i == 0) {
                 return false;
             }
         }
@@ -62,6 +78,9 @@ bool isPrime(int64_t m) {
     return true;
 }
 
+/**
+ * Main function
+ */
 int main() {
     int64_t a, m;
     // Take input of  a and m.
@@ -71,7 +90,7 @@ int main() {
     std::cin >> a >> m;
     if (isPrime(m)) {
         std::cout << "The modular inverse of a with mod m is (a^(m-2)) : ";
-        std::cout << binExpo(a, m-2, m) << std::endl;
+        std::cout << binExpo(a, m - 2, m) << std::endl;
     } else {
         std::cout << "m must be a prime number.";
         std::cout << std::endl;

From f432c0f5840d1151e4b4491abc55303e8dc8d4d9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 16:22:10 -0400
Subject: [PATCH 129/290] documetnation for positive divisors

---
 math/number_of_positive_divisors.cpp | 46 ++++++++++++++++------------
 1 file changed, 27 insertions(+), 19 deletions(-)

diff --git a/math/number_of_positive_divisors.cpp b/math/number_of_positive_divisors.cpp
index 48ab63c36..f157f7b41 100644
--- a/math/number_of_positive_divisors.cpp
+++ b/math/number_of_positive_divisors.cpp
@@ -1,34 +1,39 @@
-/// C++ Program to calculate number of divisors.
-
-#include<iostream>
-#include<vector>
-
 /**
+ * @file
+ * @brief C++ Program to calculate number of divisors
+ *
  * This algorithm use the prime factorization approach.
  * Any number can be written in multiplication of its prime factors.
- * Let N = P1^E1 * P2^E2 ... Pk^Ek
- * Therefore. number-of-divisors(N) = (E1+1) * (E2+1) ... (Ek+1).
- * Where P1, P2 ... Pk are prime factors and E1, E2 ... Ek are exponents respectively.
+ * <br/>Let N = P1^E1 * P2^E2 ... Pk^Ek
+ * <br/>Therefore. number-of-divisors(N) = (E1+1) * (E2+1) ... (Ek+1).
+ * <br/>Where P1, P2 ... Pk are prime factors and E1, E2 ... Ek are exponents
+respectively.
  *
  * Example:-
- * N = 36
- * 36 = (3^2 * 2^2)
- * number_of_positive_divisors(36) = (2+1) * (2+1) = 9.
- * list of positive divisors of 36 = 1, 2, 3, 4, 6, 9, 12, 18, 36.
+ * <br/>N = 36
+ * <br/>36 = (3^2 * 2^2)
+ * <br/>number_of_positive_divisors(36) = (2+1) * (2+1) = 9.
+ * <br/>list of positive divisors of 36 = 1, 2, 3, 4, 6, 9, 12, 18, 36.
  *
  * Similarly if N is -36 at that time number of positive divisors remain same.
  *
  * Example:-
- * N = -36
- * -36 = -1 * (3^2 * 2^2)
- * number_of_positive_divisors(-36) = (2+1) * (2+1) = 9.
- * list of positive divisors of -36 = 1, 2, 3, 4, 6, 9, 12, 18, 36.
+ * <br/>N = -36
+ * <br/>-36 = -1 * (3^2 * 2^2)
+ * <br/>number_of_positive_divisors(-36) = (2+1) * (2+1) = 9.
+ * <br/>list of positive divisors of -36 = 1, 2, 3, 4, 6, 9, 12, 18, 36.
  *
 **/
 
+#include <iostream>
+#include <vector>
+
+/**
+ * Algorithm
+ */
 int number_of_positive_divisors(int n) {
     std::vector<int> prime_exponent_count;
-    for (int i=2; i*i <= n; i++) {
+    for (int i = 2; i * i <= n; i++) {
         int prime_count = 0;
         while (n % i == 0) {
             prime_count += 1;
@@ -44,13 +49,16 @@ int number_of_positive_divisors(int n) {
 
     int divisors_count = 1;
 
-    for (int i=0; i < prime_exponent_count.size(); i++) {
-        divisors_count = divisors_count * (prime_exponent_count[i]+1);
+    for (int i = 0; i < prime_exponent_count.size(); i++) {
+        divisors_count = divisors_count * (prime_exponent_count[i] + 1);
     }
 
     return divisors_count;
 }
 
+/**
+ * Main function
+ */
 int main() {
     int n;
     std::cin >> n;

From 9154d5a25dde12744898c5d5cd19ab9c1b3f0268 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 16:22:22 -0400
Subject: [PATCH 130/290] docs for large number power

---
 math/power_for_huge_numbers.cpp | 147 ++++++++++++++++----------------
 1 file changed, 73 insertions(+), 74 deletions(-)

diff --git a/math/power_for_huge_numbers.cpp b/math/power_for_huge_numbers.cpp
index bf9374228..5cb1ae514 100644
--- a/math/power_for_huge_numbers.cpp
+++ b/math/power_for_huge_numbers.cpp
@@ -1,91 +1,90 @@
+/**
+ * @file
+ * @brief Compute powers of large numbers
+ */
 #include <iostream>
-using namespace std;
 
-// Maximum number of digits in output
-// x^n where 1 <= x, n <= 10000 and overflow may happen
+/** Maximum number of digits in output
+ *  \f$x^n\f$ where \f$1 <= x,\; n <= 10000\f$ and overflow may happen
+ */
 #define MAX 100000
 
-// This function multiplies x
-// with the number represented by res[].
-// res_size is size of res[] or
-// number of digits in the number
-// represented by res[]. This function
-// uses simple school mathematics
-// for multiplication.
-// This function may value of res_size
-// and returns the new value of res_size
-int multiply(int x, int res[], int res_size)
-{
+/** This function multiplies x
+ * with the number represented by res[].
+ * res_size is size of res[] or
+ * number of digits in the number
+ * represented by res[]. This function
+ * uses simple school mathematics
+ * for multiplication.
+ * This function may value of res_size
+ * and returns the new value of res_size
+ * @param x multiplicand
+ * @param res large number representation using array
+ * @param res_size number of digits in `res`
+ */
+int multiply(int x, int res[], int res_size) {
+    // Initialize carry
+    int carry = 0;
 
-	// Initialize carry
-	int carry = 0;
+    // One by one multiply n with
+    // individual digits of res[]
+    for (int i = 0; i < res_size; i++) {
+        int prod = res[i] * x + carry;
 
-	// One by one multiply n with
-	// individual digits of res[]
-	for (int i = 0; i < res_size; i++)
-	{
-		int prod = res[i] * x + carry;
+        // Store last digit of
+        // 'prod' in res[]
+        res[i] = prod % 10;
 
-		// Store last digit of
-		// 'prod' in res[]
-		res[i] = prod % 10;
+        // Put rest in carry
+        carry = prod / 10;
+    }
 
-		// Put rest in carry
-		carry = prod / 10;
-	}
-
-	// Put carry in res and
-	// increase result size
-	while (carry)
-	{
-		res[res_size] = carry % 10;
-		carry = carry / 10;
-		res_size++;
-	}
-	return res_size;
+    // Put carry in res and
+    // increase result size
+    while (carry) {
+        res[res_size] = carry % 10;
+        carry = carry / 10;
+        res_size++;
+    }
+    return res_size;
 }
 
-// This function finds
-// power of a number x
-void power(int x, int n)
-{
+/** This function finds power of a number x and print \f$x^n\f$
+ * @param x base
+ * @param n exponent
+ */
+void power(int x, int n) {
+    // printing value "1" for power = 0
+    if (n == 0) {
+        std::cout << "1";
+        return;
+    }
 
-	//printing value "1" for power = 0
-	if (n == 0)
-	{
-		cout << "1";
-		return;
-	}
+    int res[MAX];
+    int res_size = 0;
+    int temp = x;
 
-	int res[MAX];
-	int res_size = 0;
-	int temp = x;
+    // Initialize result
+    while (temp != 0) {
+        res[res_size++] = temp % 10;
+        temp = temp / 10;
+    }
 
-	// Initialize result
-	while (temp != 0)
-	{
-		res[res_size++] = temp % 10;
-		temp = temp / 10;
-	}
+    // Multiply x n times
+    // (x^n = x*x*x....n times)
+    for (int i = 2; i <= n; i++) res_size = multiply(x, res, res_size);
 
-	// Multiply x n times
-	// (x^n = x*x*x....n times)
-	for (int i = 2; i <= n; i++)
-		res_size = multiply(x, res, res_size);
-
-	cout << x << "^" << n << " = ";
-	for (int i = res_size - 1; i >= 0; i--)
-		cout << res[i];
+    std::cout << x << "^" << n << " = ";
+    for (int i = res_size - 1; i >= 0; i--) std::cout << res[i];
 }
 
-// Driver program
-int main()
-{
-	int exponent, base;
-	printf("Enter base ");
-	scanf("%id \n", &base);
-	printf("Enter exponent ");
-	scanf("%id", &exponent);
-	power(base, exponent);
-	return 0;
+/** Main function */
+int main() {
+    int exponent, base;
+    printf("Enter base ");
+    scanf("%id \n", &base);
+    printf("Enter exponent ");
+    scanf("%id", &exponent);
+    power(base, exponent);
+    return 0;
 }

From 093b993cc717aabdabc3886dca65bc7ba8b47348 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 16:44:58 -0400
Subject: [PATCH 131/290] fix cpplint

---
 math/extended_euclid_algorithm.cpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/math/extended_euclid_algorithm.cpp b/math/extended_euclid_algorithm.cpp
index 84dec55c5..3fdae25b5 100644
--- a/math/extended_euclid_algorithm.cpp
+++ b/math/extended_euclid_algorithm.cpp
@@ -16,15 +16,15 @@
  * function to update the coefficients per iteration
  * \f[r_0,\,r = r,\, r_0 - \text{quotient}\times r\f]
  *
- * @param[in,out] r signed
- * @param[in,out] r0 signed
- * @param[in] quotient  unsigned input
+ * @param[in,out] r signed or unsigned
+ * @param[in,out] r0 signed or unsigned
+ * @param[in] quotient  unsigned
  */
 template <typename T, typename T2>
-inline void update_step(T &r, T &r0, const T2 quotient) {
-    T temp = r;
-    r = r0 - (quotient * temp);
-    r0 = temp;
+inline void update_step(T *r, T *r0, const T2 quotient) {
+    T temp = *r;
+    *r = *r0 - (quotient * temp);
+    *r0 = temp;
 }
 
 /**
@@ -47,9 +47,9 @@ void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y) {
 
     while (r != 0) {
         T1 quotient = r0 / r;
-        update_step(r, r0, quotient);
-        update_step(s, s0, quotient);
-        update_step(t, t0, quotient);
+        update_step(&r, &r0, quotient);
+        update_step(&s, &s0, quotient);
+        update_step(&t, &t0, quotient);
     }
     *GCD = r0;
     *x = s0;

From ea3f8bbf29381b0a999891d6590c934cd2cdbacc Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 16:45:33 -0400
Subject: [PATCH 132/290] documentation and bug fixes

---
 math/prime_factorization.cpp   | 22 ++++++----
 math/prime_numbers.cpp         | 15 +++++--
 math/primes_up_to_billion.cpp  | 10 +++++
 math/sieve_of_eratosthenes.cpp | 74 ++++++++++++++++------------------
 4 files changed, 71 insertions(+), 50 deletions(-)

diff --git a/math/prime_factorization.cpp b/math/prime_factorization.cpp
index c018de666..d0e05cb4c 100644
--- a/math/prime_factorization.cpp
+++ b/math/prime_factorization.cpp
@@ -1,15 +1,25 @@
+/**
+ * @file
+ * @brief Prime factorization of positive integers
+ */
 #include <algorithm>
 #include <cstring>
 #include <iostream>
 #include <vector>
 
-// Declaring variables for maintaing prime numbers and to check whether a number
-// is prime or not
+/** Declaring variables for maintaing prime numbers and to check whether a
+ * number is prime or not
+ */
 bool isprime[1000006];
+
+/** list of prime numbers */
 std::vector<int> prime_numbers;
+
+/** list of prime factor-pairs */
 std::vector<std::pair<int, int>> factors;
 
-// Calculating prime number upto a given range
+/** Calculating prime number upto a given range
+ */
 void SieveOfEratosthenes(int N) {
     // initializes the array isprime
     memset(isprime, true, sizeof isprime);
@@ -25,7 +35,7 @@ void SieveOfEratosthenes(int N) {
     }
 }
 
-// Prime factorization of a number
+/** Prime factorization of a number */
 void prime_factorization(int num) {
     int number = num;
 
@@ -46,9 +56,7 @@ void prime_factorization(int num) {
     }
 }
 
-/*
-    I added a simple UI.
-*/
+/** Main program */
 int main() {
     int num;
     std::cout << "\t\tComputes the prime factorization\n\n";
diff --git a/math/prime_numbers.cpp b/math/prime_numbers.cpp
index 7264ff528..4dd54f136 100644
--- a/math/prime_numbers.cpp
+++ b/math/prime_numbers.cpp
@@ -1,26 +1,33 @@
+/**
+ * @file
+ * @brief Get list of prime numbers
+ * @see primes_up_to_billion.cpp sieve_of_eratosthenes.cpp
+ */
 #include <iostream>
 #include <vector>
 
+/** Generate an increasingly large number of primes
+ * and store in a list
+ */
 std::vector<int> primes(int max) {
     max++;
     std::vector<int> res;
     std::vector<bool> numbers(max, false);
     for (int i = 2; i < max; i++) {
         if (!numbers[i]) {
-            for (int j = i; j < max; j += i)
-                numbers[j] = true;
+            for (int j = i; j < max; j += i) numbers[j] = true;
             res.push_back(i);
         }
     }
     return res;
 }
 
+/** main function */
 int main() {
     std::cout << "Calculate primes up to:\n>> ";
     int n;
     std::cin >> n;
     std::vector<int> ans = primes(n);
-    for (int i = 0; i < ans.size(); i++)
-        std::cout << ans[i] << ' ';
+    for (int i = 0; i < ans.size(); i++) std::cout << ans[i] << ' ';
     std::cout << std::endl;
 }
diff --git a/math/primes_up_to_billion.cpp b/math/primes_up_to_billion.cpp
index d8f5a9f9d..4fb79a15e 100644
--- a/math/primes_up_to_billion.cpp
+++ b/math/primes_up_to_billion.cpp
@@ -1,8 +1,15 @@
+/**
+ * @file
+ * @brief Compute prime numbers upto 1 billion
+ * @see prime_numbers.cpp sieve_of_eratosthenes.cpp
+ */
 #include <cstring>
 #include <iostream>
 
+/** array to store the primes */
 char prime[100000000];
 
+/** Perform Sieve algorithm */
 void Sieve(int64_t n) {
     memset(prime, '1', sizeof(prime));  // intitize '1' to every index
     prime[0] = '0';                     // 0 is not prime
@@ -15,6 +22,7 @@ void Sieve(int64_t n) {
     }
 }
 
+/** Main function */
 int main() {
     Sieve(100000000);
     int64_t n;
@@ -23,4 +31,6 @@ int main() {
         std::cout << "YES\n";
     else
         std::cout << "NO\n";
+
+    return 0;
 }
diff --git a/math/sieve_of_eratosthenes.cpp b/math/sieve_of_eratosthenes.cpp
index e600e480d..d8fa70531 100644
--- a/math/sieve_of_eratosthenes.cpp
+++ b/math/sieve_of_eratosthenes.cpp
@@ -1,69 +1,65 @@
-/*
- * Sieve of Eratosthenes is an algorithm to find the primes 
+/**
+ * @file
+ * @brief Get list of prime numbers using Sieve of Eratosthenes
+ * Sieve of Eratosthenes is an algorithm to find the primes
  * that is between 2 to N (as defined in main).
  *
- * Time Complexity  : O(N * log N)
- * Space Complexity : O(N)
+ * Time Complexity  : \f$O(N \cdot\log N)\f$
+ * <br/>Space Complexity : \f$O(N)\f$
+ *
+ * @see primes_up_to_billion.cpp prime_numbers.cpp
  */
 
 #include <iostream>
-using namespace std;
 
+/** Maximum number of primes */
 #define MAX 10000000
 
-int isprime[MAX];
+/** array to store the primes */
+bool isprime[MAX];
 
-/*
- * This is the function that finds the primes and eliminates 
+/**
+ * This is the function that finds the primes and eliminates
  * the multiples.
  */
-void sieve(int N)
-{
-    isprime[0] = 0;
-    isprime[1] = 0;
-    for (int i = 2; i <= N; i++)
-    {
-        if (isprime[i])
-        {
-            for (int j = i * 2; j <= N; j += i)
-            {
-                isprime[j] = 0;
+void sieve(uint32_t N) {
+    isprime[0] = false;
+    isprime[1] = false;
+    for (uint32_t i = 2; i <= N; i++) {
+        if (isprime[i]) {
+            for (uint32_t j = (i << 1); j <= N; j += i) {
+                isprime[j] = false;
             }
         }
     }
 }
 
-/*
+/**
  * This function prints out the primes to STDOUT
  */
-void print(int N)
-{
-    for (int i = 1; i <= N; i++)
-    {
-        if (isprime[i] == 1)
-        {
-            cout << i << ' ';
+void print(uint32_t N) {
+    for (uint32_t i = 1; i <= N; i++) {
+        if (isprime[i]) {
+            std::cout << i << ' ';
         }
     }
-    cout << '\n';
+    std::cout << std::endl;
 }
 
-/*
- * NOTE: This function is important for the 
- * initialization of the array.
+/**
+ * Initialize the array
  */
-void init()
-{
-    for (int i = 1; i < MAX; i++)
-    {
-        isprime[i] = 1;
+void init() {
+    for (uint32_t i = 1; i < MAX; i++) {
+        isprime[i] = true;
     }
 }
 
-int main()
-{
-    int N = 100;
+/** main function */
+int main() {
+    uint32_t N = 100;
     init();
     sieve(N);
     print(N);
+    return 0;
 }

From 6cd589a75287298317b04ed2e221bd63f0a7c593 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 16:47:32 -0400
Subject: [PATCH 133/290] math readme title

---
 math/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/math/README.md b/math/README.md
index 4ac39c878..d7b862f9f 100644
--- a/math/README.md
+++ b/math/README.md
@@ -1,3 +1,4 @@
+# Prime factorization # {#section}
 Prime Factorization is a very important and useful technique to factorize any number into its prime factors. It has various applications in the field of number theory.
 
 The method of prime factorization involves two function calls.

From 27cea79fa3538ab18c36d3aa64c28624041b1357 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 16:58:30 -0400
Subject: [PATCH 134/290] document square-root that uses bisection method

---
 math/sqrt_double.cpp | 50 ++++++++++++++++++++++++++------------------
 1 file changed, 30 insertions(+), 20 deletions(-)

diff --git a/math/sqrt_double.cpp b/math/sqrt_double.cpp
index 5a0fd1c88..1521b500a 100644
--- a/math/sqrt_double.cpp
+++ b/math/sqrt_double.cpp
@@ -1,27 +1,35 @@
-#include <iostream>
+/**
+ * @file
+ * @brief Calculate the square root of any positive number in \f$O(\log N)\f$
+ * time, with precision fixed using [bisection
+ * method](https://en.wikipedia.org/wiki/Bisection_method) of root-finding.
+ *
+ * @see Can be implemented using faster and better algorithms like
+ * newton_raphson_method.cpp and false_position.cpp
+ */
 #include <cassert>
+#include <iostream>
 
-/* Calculate the square root of any 
-number in O(logn) time, 
-with precision fixed */
-
-double Sqrt(double x) {
-    if ( x > 0 && x < 1 ) {
-        return 1/Sqrt(1/x);
+/** Bisection method implemented for the function \f$x^2-a=0\f$
+ * whose roots are \f$\pm\sqrt{a}\f$ and only the positive root is returned.
+ */
+double Sqrt(double a) {
+    if (a > 0 && a < 1) {
+        return 1 / Sqrt(1 / a);
     }
-    double l = 0, r = x;
-    /* Epsilon is the precision. 
-    A great precision is 
+    double l = 0, r = a;
+    /* Epsilon is the precision.
+    A great precision is
     between 1e-7 and 1e-12.
     double epsilon = 1e-12;
     */
     double epsilon = 1e-12;
-    while ( l <= r ) {
+    while (l <= r) {
         double mid = (l + r) / 2;
-        if ( mid * mid > x ) {
+        if (mid * mid > a) {
             r = mid;
         } else {
-            if ( x - mid * mid < epsilon ) {
+            if (a - mid * mid < epsilon) {
                 return mid;
             }
             l = mid;
@@ -29,11 +37,13 @@ double Sqrt(double x) {
     }
     return -1;
 }
+
+/** main function */
 int main() {
-  double n{};
-  std::cin >> n;
-  assert(n >= 0);
-  // Change this line for a better precision
-  std::cout.precision(12);
-  std::cout << std::fixed << Sqrt(n);
+    double n{};
+    std::cin >> n;
+    assert(n >= 0);
+    // Change this line for a better precision
+    std::cout.precision(12);
+    std::cout << std::fixed << Sqrt(n);
 }

From 9965614174f64085422d1a82fa6a67273cc730fb Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 17:32:10 -0400
Subject: [PATCH 135/290] added documetnation to large_factorial.cpp

---
 others/large_factorial.cpp | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
index 6d5385589..1027f41ab 100644
--- a/others/large_factorial.cpp
+++ b/others/large_factorial.cpp
@@ -1,10 +1,18 @@
-#include <string.h>
-
+/**
+ * @file
+ * @brief Compute factorial of any arbitratily large number/
+ *
+ * @see factorial.cpp
+ */
+#include <cstring>
 #include <ctime>
 #include <iostream>
 
 #include "./large_number.h"
 
+/** Test implementation for 10! Result must be 3628800.
+ * @returns True if test pass else False
+ */
 bool test1() {
     std::cout << "---- Check 1\t";
     unsigned int i, number = 10;
@@ -34,6 +42,14 @@ bool test1() {
     return true;
 }
 
+/** Test implementation for 100! The result is the 156 digit number:
+ * ```
+ * 9332621544394415268169923885626670049071596826438162146859296389521759
+ * 9993229915608941463976156518286253697920827223758251185210916864000000
+ * 000000000000000000
+ * ```
+ * @returns True if test pass else False
+ */
 bool test2() {
     std::cout << "---- Check 2\t";
     unsigned int i, number = 100;

From 772e7fb789be4a7db263bb2f1cabc0fc829f6042 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 17:32:46 -0400
Subject: [PATCH 136/290] removed author details from comments for header file

---
 others/large_number.h | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/others/large_number.h b/others/large_number.h
index 544682987..959622187 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -1,8 +1,8 @@
 /**
  * @file
- * @author Krishna Vedala
- * @email krishna (dot) vedala (at) ieee (dot) org
- **/
+ * @brief Library to perform arithmatic operations on arbitrarily large
+ * numbers.
+ */
 
 #ifndef OTHERS_LARGE_NUMBER_H_
 #define OTHERS_LARGE_NUMBER_H_
@@ -53,7 +53,8 @@ class large_number {
     explicit large_number(char const *number_str) {
         for (size_t i = strlen(number_str); i > 0; i--) {
             unsigned char a = number_str[i - 1] - '0';
-            if (a >= 0 && a <= 9) _digits.push_back(a);
+            if (a >= 0 && a <= 9)
+                _digits.push_back(a);
         }
     }
 
@@ -152,9 +153,11 @@ class large_number {
      **/
     friend bool operator==(large_number const &a, large_number const &b) {
         size_t N = a.num_digits();
-        if (N != b.num_digits()) return false;
+        if (N != b.num_digits())
+            return false;
         for (size_t i = 0; i < N; i++)
-            if (a[i] != b[i]) return false;
+            if (a[i] != b[i])
+                return false;
         return true;
     }
 
@@ -192,8 +195,10 @@ class large_number {
         unsigned int carry = 0;
         size_t i;
         for (i = 0; i < max_L || carry != 0; i++) {
-            if (i < b->num_digits()) carry += (*b)[i];
-            if (i < this->num_digits()) carry += (*this)[i];
+            if (i < b->num_digits())
+                carry += (*b)[i];
+            if (i < this->num_digits())
+                carry += (*this)[i];
             if (i < this->num_digits())
                 (*this)[i] = carry % 10;
             else

From 962e27a2bef143b13266ba18142a220f6b59eac3 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Wed, 27 May 2020 21:38:10 +0000
Subject: [PATCH 137/290] updating DIRECTORY.md

---
 DIRECTORY.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 37132246b..d627af28c 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -138,6 +138,7 @@
   * [Decimal To Roman Numeral](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_roman_numeral.cpp)
   * [Fast Interger Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_interger_input.cpp)
   * [Fibonacci Fast](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_fast.cpp)
+  * [Fibonacci Large](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_large.cpp)
   * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/gcd_of_n_numbers.cpp)
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
   * [Large Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/large_factorial.cpp)

From 0228c388e4b8f6c8081c71d0c35e4b160d89f4e5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Wed, 27 May 2020 17:43:02 -0400
Subject: [PATCH 138/290] use the correct repo for badges

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 4befc6afa..9f16cb6b2 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # The Algorithms - C++ # {#mainpage}
-[![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
-![GitHub repo size](https://img.shields.io/github/repo-size/TheAlgorithms/C-Plus-Plus?color=red&style=flat-square)
+[![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
+![GitHub repo size](https://img.shields.io/github/repo-size/kvedala/C-Plus-Plus?color=red&style=flat-square)
 ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/TheAlgorithms/C-Plus-Plus?color=green&style=flat-square)
 ![Doxygen CI](https://github.com/kvedala/C-Plus-Plus/workflows/Doxygen%20CI/badge.svg)
 ![cpplint](https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg)

From 08470a9e2226bd4d5861e2bb5b3e4517cb0098bc Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Wed, 27 May 2020 17:43:37 -0400
Subject: [PATCH 139/290] fixed another repo badge link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9f16cb6b2..b56c4f5f4 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # The Algorithms - C++ # {#mainpage}
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
 ![GitHub repo size](https://img.shields.io/github/repo-size/kvedala/C-Plus-Plus?color=red&style=flat-square)
-![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/TheAlgorithms/C-Plus-Plus?color=green&style=flat-square)
+![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/kvedala/C-Plus-Plus?color=green&style=flat-square)
 ![Doxygen CI](https://github.com/kvedala/C-Plus-Plus/workflows/Doxygen%20CI/badge.svg)
 ![cpplint](https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg)
 ![C/C++ CI](https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg)

From c27fa436b894a2cf9dfcd45e9df6c1eac156ff34 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 17:57:38 -0400
Subject: [PATCH 140/290] remove redundant file

---
 others/sieve_of_Eratosthenes.cpp | 60 --------------------------------
 1 file changed, 60 deletions(-)
 delete mode 100644 others/sieve_of_Eratosthenes.cpp

diff --git a/others/sieve_of_Eratosthenes.cpp b/others/sieve_of_Eratosthenes.cpp
deleted file mode 100644
index e87ad4983..000000000
--- a/others/sieve_of_Eratosthenes.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Sieve of Eratosthenes is an algorithm to find the primes 
- * that is between 2 to N (as defined in main).
- *
- * Time Complexity  : O(N)
- * Space Complexity : O(N)
- */
-
-#include <iostream>
-using namespace std;
-
-#define MAX 10000000
-
-int primes[MAX];
-
-/*
- * This is the function that finds the primes and eliminates 
- * the multiples.
- */
-void sieve(int N)
-{
-  primes[0] = 1;
-  primes[1] = 1;
-  for (int i = 2; i <= N; i++)
-  {
-    if (primes[i] == 1)
-      continue;
-    for (int j = i + i; j <= N; j += i)
-      primes[j] = 1;
-  }
-}
-
-/*
- * This function prints out the primes to STDOUT
- */
-void print(int N)
-{
-  for (int i = 0; i <= N; i++)
-    if (primes[i] == 0)
-      cout << i << ' ';
-  cout << '\n';
-}
-
-/*
- * NOTE: This function is important for the 
- * initialization of the array.
- */
-void init()
-{
-  for (int i = 0; i < MAX; i++)
-    primes[i] = 0;
-}
-
-int main()
-{
-  int N = 100;
-  init();
-  sieve(N);
-  print(N);
-}

From 6dfdfa6662938fe0d932fd7d81b9ca9d1ef4032c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 17:58:17 -0400
Subject: [PATCH 141/290] fibonacci documentation

---
 math/fibonacci.cpp         |  5 ++++-
 others/fibonacci_large.cpp | 11 +++++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index 1a5f4afb4..034b91970 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -5,6 +5,8 @@
  * Calculate the the value on Fibonacci's sequence given an
  * integer as input.
  * \f[\text{fib}(n) = \text{fib}(n-1) + \text{fib}(n-2)\f]
+ *
+ * @see fibonacci_large.cpp
  */
 #include <cassert>
 #include <iostream>
@@ -15,7 +17,8 @@
 int fibonacci(unsigned int n) {
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
-    if (n <= 1) return n;
+    if (n <= 1)
+        return n;
 
     /* Add the last 2 values of the sequence to get next */
     return fibonacci(n - 1) + fibonacci(n - 2);
diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index 6f36702a2..6b556066a 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -1,11 +1,14 @@
 /**
- * Computes N^th Fibonacci number given as
+ * @file
+ * @brief Computes N^th Fibonacci number given as
  * input argument. Uses custom build arbitrary integers library
  * to perform additions and other operations.
  *
  * Took 0.608246 seconds to compute 50,000^th Fibonacci
  * number that contains 10450 digits!
- **/
+ *
+ * @see fibonacci.cpp
+ */
 
 #include <cinttypes>
 #include <ctime>
@@ -13,6 +16,10 @@
 
 #include "./large_number.h"
 
+/** Compute fibonacci numbers using the relation
+ * \f[f(n)=f(n-1)+f(n-2)\f]
+ * and returns the result as a large_number type.
+ */
 large_number fib(uint64_t n) {
     large_number f0(1);
     large_number f1(1);

From e963ba4c5b22f0e0984c60d474d329e88e761f93 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:00:02 -0400
Subject: [PATCH 142/290] fix buzz number

---
 others/buzz_number.cpp | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/others/buzz_number.cpp b/others/buzz_number.cpp
index f31038aad..ed9fc5f28 100644
--- a/others/buzz_number.cpp
+++ b/others/buzz_number.cpp
@@ -1,17 +1,20 @@
-//A buzz number is a number that is either divisble by 7 or has last digit as 7.
+/**
+ * @file
+ * @brief A buzz number is a number that is either divisible by 7 or has last
+ * digit as 7.
+ */
 #include <iostream>
-using namespace std;
-int main()
-{
-  int n, t;
-  cin >> t;
-  while (t--)
-  {
-    cin >> n;
-    if ((n % 7 == 0) || (n % 10 == 7))
-      cout << n << " is a buzz number" << endl;
-    else
-      cout << n << " is not a buzz number" << endl;
-  }
-  return 0;
+
+/** main function */
+int main() {
+    int n, t;
+    std::cin >> t;
+    while (t--) {
+        std::cin >> n;
+        if ((n % 7 == 0) || (n % 10 == 7))
+            std::cout << n << " is a buzz number" << std::endl;
+        else
+            std::cout << n << " is not a buzz number" << std::endl;
+    }
+    return 0;
 }

From e7632d107caddbf7928f872f509678e678a5262c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:16:32 -0400
Subject: [PATCH 143/290] fixed CPPLINT + added method 2

---
 others/decimal_to_binary.cpp | 72 +++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 21 deletions(-)

diff --git a/others/decimal_to_binary.cpp b/others/decimal_to_binary.cpp
index 4e2119ebc..11ce064a5 100644
--- a/others/decimal_to_binary.cpp
+++ b/others/decimal_to_binary.cpp
@@ -1,25 +1,55 @@
-// This function convert decimal to binary number
-//
+/**
+ * @file
+ * @brief Function to convert decimal number to binary representation
+ */
 #include <iostream>
-using namespace std;
 
-int main()
-{
-	int number;
-	cout << "Enter a number:";
-	cin >> number;
-	int remainder, binary = 0, var = 1;
+/**
+ * This method converts the bit representation and stores it as a decimal
+ * number.
+ */
+void method1(int number) {
+    int remainder, binary = 0, var = 1;
 
-	do
-	{
-		remainder = number % 2;
-		number = number / 2;
-		binary = binary + (remainder * var);
-		var = var * 10;
-
-	} while (number > 0);
-	cout << "the binary is :";
-	cout << binary;
-	cout << endl;
-	return 0;
+    do {
+        remainder = number % 2;
+        number = number / 2;
+        binary = binary + (remainder * var);
+        var = var * 10;
+    } while (number > 0);
+    std::cout << "Method 1 : " << binary << std::endl;
+}
+
+/**
+ * This method stores each bit value from LSB to MSB and then prints them back
+ * from MSB to LSB
+ */
+void method2(int number) {
+    int num_bits = 0;
+    char bit_string[50];
+
+    do {
+        bool bit = number & 0x01;  // get last bit
+        if (bit)
+            bit_string[num_bits++] = '1';
+        else
+            bit_string[num_bits++] = '0';
+        number >>= 1;  // right shift bit 1 bit
+    } while (number > 0);
+
+    std::cout << "Method 2 : ";
+    while (num_bits >= 0)
+        std::cout << bit_string[num_bits--];  // print from MSB to LSB
+    std::cout << std::endl;
+}
+
+int main() {
+    int number;
+    std::cout << "Enter a number:";
+    std::cin >> number;
+
+    method1(number);
+    method2(number);
+
+    return 0;
 }

From 7e875baab71de9b02537e7d9a1075ec9bdc4ccc3 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:22:49 -0400
Subject: [PATCH 144/290] fixed decimal to hex

---
 others/decimal_to_hexadecimal.cpp | 48 +++++++++++++++++--------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/others/decimal_to_hexadecimal.cpp b/others/decimal_to_hexadecimal.cpp
index 705f21ba4..a3e544f49 100644
--- a/others/decimal_to_hexadecimal.cpp
+++ b/others/decimal_to_hexadecimal.cpp
@@ -1,28 +1,34 @@
+/**
+ * @file
+ * @brief Convert decimal number to hexadecimal representation
+ */
+
 #include <iostream>
 
-using namespace std;
+/**
+ * Main program
+ */
+int main(void) {
+    int valueToConvert = 0;  // Holds user input
+    int hexArray[8];         // Contains hex values backwards
+    int i = 0;               // counter
+    char HexValues[] = "0123456789ABCDEF";
 
-int main(void)
-{
-	int valueToConvert = 0; //Holds user input
-	int hexArray[8];		//Contains hex values backwards
-	int i = 0;				//counter
-	char HexValues[] = "0123456789ABCDEF";
+    std::cout << "Enter a Decimal Value"
+              << std::endl;  // Displays request to stdout
+    std::cin >>
+        valueToConvert;  // Stores value into valueToConvert via user input
 
-	cout << "Enter a Decimal Value" << endl; //Displays request to stdout
-	cin >> valueToConvert;					 //Stores value into valueToConvert via user input
+    while (valueToConvert > 15) {             // Dec to Hex Algorithm
+        hexArray[i++] = valueToConvert % 16;  // Gets remainder
+        valueToConvert /= 16;
+        // valueToConvert >>= 4;  // This will divide by 2^4=16 and is faster
+    }
+    hexArray[i] = valueToConvert;  // Gets last value
 
-	while (valueToConvert > 15)
-	{										 //Dec to Hex Algorithm
-		hexArray[i++] = valueToConvert % 16; //Gets remainder
-		valueToConvert /= 16;
-	}
-	hexArray[i] = valueToConvert; //Gets last value
+    std::cout << "Hex Value: ";
+    while (i >= 0) std::cout << HexValues[hexArray[i--]];
 
-	cout << "Hex Value: ";
-	while (i >= 0)
-		cout << HexValues[hexArray[i--]];
-
-	cout << endl;
-	return 0;
+    std::cout << std::endl;
+    return 0;
 }

From a8bdbbda355be055f5d99fa7e3dfcd71ea9a0ba9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:22:57 -0400
Subject: [PATCH 145/290] fixed decimal to roman

---
 others/decimal_to_roman_numeral.cpp | 131 ++++++++++++----------------
 1 file changed, 55 insertions(+), 76 deletions(-)

diff --git a/others/decimal_to_roman_numeral.cpp b/others/decimal_to_roman_numeral.cpp
index 0372e8003..6bd1be395 100644
--- a/others/decimal_to_roman_numeral.cpp
+++ b/others/decimal_to_roman_numeral.cpp
@@ -1,97 +1,76 @@
-//This Programme Converts a given decimal number in the range [0,4000)
-//to both Lower case and Upper case Roman Numeral
+/**
+ * @file
+ * @brief This Programme Converts a given decimal number in the range [0,4000)
+ * to both Lower case and Upper case Roman Numeral
+ */
 
 #include <cmath>
 #include <cstdio>
-#include <string>
+#include <cstring>
 #include <iostream>
-using namespace std;
 
-//This functions fills a string with character c, n times and returns it
-string fill(char c, int n)
-{
-    string s = "";
-    while (n--)
-        s += c;
+/** This functions fills a string with character c, n times and returns it
+ * @note This can probably be replace by `memcpy` function.
+ */
+std::string fill(char c, int n) {
+    std::string s = "";
+    while (n--) s += c;
     return s;
 }
 
-//to convert to lowercase Roman Numeral
-// the function works recursively
-string tolowerRoman(int n)
-{
-    if (n < 4)
-        return fill('i', n);
-    if (n < 6)
-        return fill('i', 5 - n) + "v";
-    if (n < 9)
-        return string("v") + fill('i', n - 5);
-    if (n < 11)
-        return fill('i', 10 - n) + "x";
-    if (n < 40)
-        return fill('x', n / 10) + tolowerRoman(n % 10);
-    if (n < 60)
-        return fill('x', 5 - n / 10) + 'l' + tolowerRoman(n % 10);
+/** to convert to lowercase Roman Numeral
+ * the function works recursively
+ */
+std::string tolowerRoman(int n) {
+    if (n < 4) return fill('i', n);
+    if (n < 6) return fill('i', 5 - n) + "v";
+    if (n < 9) return std::string("v") + fill('i', n - 5);
+    if (n < 11) return fill('i', 10 - n) + "x";
+    if (n < 40) return fill('x', n / 10) + tolowerRoman(n % 10);
+    if (n < 60) return fill('x', 5 - n / 10) + 'l' + tolowerRoman(n % 10);
     if (n < 90)
-        return string("l") + fill('x', n / 10 - 5) + tolowerRoman(n % 10);
-    if (n < 110)
-        return fill('x', 10 - n / 10) + "c" + tolowerRoman(n % 10);
-    if (n < 400)
-        return fill('c', n / 100) + tolowerRoman(n % 100);
-    if (n < 600)
-        return fill('c', 5 - n / 100) + 'd' + tolowerRoman(n % 100);
+        return std::string("l") + fill('x', n / 10 - 5) + tolowerRoman(n % 10);
+    if (n < 110) return fill('x', 10 - n / 10) + "c" + tolowerRoman(n % 10);
+    if (n < 400) return fill('c', n / 100) + tolowerRoman(n % 100);
+    if (n < 600) return fill('c', 5 - n / 100) + 'd' + tolowerRoman(n % 100);
     if (n < 900)
-        return string("d") + fill('c', n / 100 - 5) + tolowerRoman(n % 100);
-    if (n < 1100)
-        return fill('c', 10 - n / 100) + "m" + tolowerRoman(n % 100);
-    if (n < 4000)
-        return fill('m', n / 1000) + tolowerRoman(n % 1000);
+        return std::string("d") + fill('c', n / 100 - 5) +
+               tolowerRoman(n % 100);
+    if (n < 1100) return fill('c', 10 - n / 100) + "m" + tolowerRoman(n % 100);
+    if (n < 4000) return fill('m', n / 1000) + tolowerRoman(n % 1000);
     return "?";
 }
 
-//to convert to uppercase Roman Numeral
-// the function works recursively
-string toupperRoman(int n)
-{
-    if (n < 4)
-        return fill('I', n);
-    if (n < 6)
-        return fill('I', 5 - n) + "V";
-    if (n < 9)
-        return string("V") + fill('I', n - 5);
-    if (n < 11)
-        return fill('I', 10 - n) + "X";
-    if (n < 40)
-        return fill('X', n / 10) + toupperRoman(n % 10);
-    if (n < 60)
-        return fill('X', 5 - n / 10) + 'L' + toupperRoman(n % 10);
+/** to convert to uppercase Roman Numeral
+ * the function works recursively
+ */
+std::string toupperRoman(int n) {
+    if (n < 4) return fill('I', n);
+    if (n < 6) return fill('I', 5 - n) + "V";
+    if (n < 9) return std::string("V") + fill('I', n - 5);
+    if (n < 11) return fill('I', 10 - n) + "X";
+    if (n < 40) return fill('X', n / 10) + toupperRoman(n % 10);
+    if (n < 60) return fill('X', 5 - n / 10) + 'L' + toupperRoman(n % 10);
     if (n < 90)
-        return string("L") + fill('X', n / 10 - 5) + toupperRoman(n % 10);
-    if (n < 110)
-        return fill('X', 10 - n / 10) + "C" + toupperRoman(n % 10);
-    if (n < 400)
-        return fill('C', n / 100) + toupperRoman(n % 100);
-    if (n < 600)
-        return fill('C', 5 - n / 100) + 'D' + toupperRoman(n % 100);
+        return std::string("L") + fill('X', n / 10 - 5) + toupperRoman(n % 10);
+    if (n < 110) return fill('X', 10 - n / 10) + "C" + toupperRoman(n % 10);
+    if (n < 400) return fill('C', n / 100) + toupperRoman(n % 100);
+    if (n < 600) return fill('C', 5 - n / 100) + 'D' + toupperRoman(n % 100);
     if (n < 900)
-        return string("D") + fill('C', n / 100 - 5) + toupperRoman(n % 100);
-    if (n < 1100)
-        return fill('C', 10 - n / 100) + "M" + toupperRoman(n % 100);
-    if (n < 4000)
-        return fill('M', n / 1000) + toupperRoman(n % 1000);
+        return std::string("D") + fill('C', n / 100 - 5) +
+               toupperRoman(n % 100);
+    if (n < 1100) return fill('C', 10 - n / 100) + "M" + toupperRoman(n % 100);
+    if (n < 4000) return fill('M', n / 1000) + toupperRoman(n % 1000);
     return "?";
 }
 
-//main function
-
-int main()
-{
-
+/** main function */
+int main() {
     int n;
-    cout << "\t\tRoman numbers converter\n\n";
-    cout << "Type in decimal number between 0 up to 4000 (exclusive): ";
-    cin >> n;
-    cout << n << " in Upper Roman Numerals is " << toupperRoman(n) << "\n";
-    cout << n << " in Lower Roman Numerals is " << tolowerRoman(n) << "\n";
+    std::cout << "\t\tRoman numbers converter\n\n";
+    std::cout << "Type in decimal number between 0 up to 4000 (exclusive): ";
+    std::cin >> n;
+    std::cout << n << " in Upper Roman Numerals is " << toupperRoman(n) << "\n";
+    std::cout << n << " in Lower Roman Numerals is " << tolowerRoman(n) << "\n";
     return 0;
 }

From 9249fa274323bf44c7c83bc152efc37f3268fc83 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Wed, 27 May 2020 22:41:28 +0000
Subject: [PATCH 146/290] updating DIRECTORY.md

---
 DIRECTORY.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index d627af28c..e99f32611 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -148,7 +148,6 @@
   * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)
   * [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp)
   * [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/primality_test.cpp)
-  * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sieve_of_Eratosthenes.cpp)
   * [Smallest-Circle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/smallest-circle.cpp)
   * [Sparse Matrix](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sparse_matrix.cpp)
   * [Spiral Print](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/spiral_print.cpp)

From 7238aa78697f217dd06e5d88a020fcd5a9630b0f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:45:52 -0400
Subject: [PATCH 147/290] fix merge conflicts

---
 sorting/quick_sort.cpp | 63 ++++++++++++------------------------------
 1 file changed, 17 insertions(+), 46 deletions(-)

diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
index eaa5981f3..1db6b014e 100644
--- a/sorting/quick_sort.cpp
+++ b/sorting/quick_sort.cpp
@@ -1,16 +1,6 @@
-<<<<<<< HEAD
-/* C implementation QuickSort */
-#include <iostream>
-
-int partition(int arr[], int low, int high) {
-    int pivot = arr[high];  // pivot
-    int i = (low - 1);      // Index of smaller element
-=======
 /**
- *
- *      copyright The Algorithms
- *      Author - 
- *      Correction - ayaankhan98
+ * @file
+ * @brief Quick sort algorithm
  *
  * Implementation Details -
  *      Quick Sort is a divide and conquer algorithm. It picks and element as
@@ -35,28 +25,23 @@ int partition(int arr[], int low, int high) {
 #include <iostream>
 
 /**
- *      This function takes last element as pivot, places  
- *      the pivot element at its correct position in sorted  
- *      array, and places all smaller (smaller than pivot)  
- *      to left of pivot and all greater elements to right  
- *      of pivot 
+ *      This function takes last element as pivot, places
+ *      the pivot element at its correct position in sorted
+ *      array, and places all smaller (smaller than pivot)
+ *      to left of pivot and all greater elements to right
+ *      of pivot
  *
  */
 
 int partition(int arr[], int low, int high) {
-    int pivot = arr[high];    // taking the last element as pivot
-    int i = (low - 1);        // Index of smaller element
->>>>>>> major-corrections-to-files
+    int pivot = arr[high];  // taking the last element as pivot
+    int i = (low - 1);      // Index of smaller element
 
     for (int j = low; j < high; j++) {
         // If current element is smaller than or
         // equal to pivot
         if (arr[j] <= pivot) {
-<<<<<<< HEAD
             i++;  // increment index of smaller element
-=======
-            i++;   // increment index of smaller element
->>>>>>> major-corrections-to-files
             int temp = arr[i];
             arr[i] = arr[j];
             arr[j] = temp;
@@ -68,41 +53,27 @@ int partition(int arr[], int low, int high) {
     return (i + 1);
 }
 
-<<<<<<< HEAD
+/**
+ *      The main function that implements QuickSort
+ *      arr[] --> Array to be sorted,
+ *      low --> Starting index,
+ *      high --> Ending index
+ */
 void quickSort(int arr[], int low, int high) {
     if (low < high) {
         int p = partition(arr, low, high);
-
-=======
-
-/** 
- *      The main function that implements QuickSort  
- *      arr[] --> Array to be sorted,  
- *      low --> Starting index,  
- *      high --> Ending index 
-*/
-void quickSort(int arr[], int low, int high) {
-    if (low < high) {
-        int p = partition(arr, low, high);
->>>>>>> major-corrections-to-files
         quickSort(arr, low, p - 1);
         quickSort(arr, p + 1, high);
     }
 }
 
-<<<<<<< HEAD
-void show(int arr[], int size) {
-    for (int i = 0; i < size; i++) std::cout << arr[i] << "\n";
-=======
 // prints the array after sorting
 void show(int arr[], int size) {
-    for (int i = 0; i < size; i++)
-        std::cout << arr[i] << " ";
+    for (int i = 0; i < size; i++) std::cout << arr[i] << " ";
     std::cout << "\n";
->>>>>>> major-corrections-to-files
 }
 
-// Driver program to test above functions
+/** Driver program to test above functions */
 int main() {
     int size;
     std::cout << "\nEnter the number of elements : ";

From 894cd9a71db8f67b5f279ad02df873191eb49e66 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:46:22 -0400
Subject: [PATCH 148/290] document fast_integer

---
 others/fast_interger_input.cpp | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/others/fast_interger_input.cpp b/others/fast_interger_input.cpp
index 3358fc8bb..5e7bcb99d 100644
--- a/others/fast_interger_input.cpp
+++ b/others/fast_interger_input.cpp
@@ -1,7 +1,15 @@
-// Read integers in the fastest way in c plus plus
-#include<iostream>
+/**
+ * @file
+ * @brief Read integers from stdin continuously as they are entered without
+ * waiting for the `\n` character
+ */
+#include <iostream>
+
+/** Function to read the number from stdin. The function reads input until a non
+ * numeric character is entered.
+ */
 void fastinput(int *number) {
-// variable to indicate sign of input integer
+    // variable to indicate sign of input integer
     bool negative = false;
     register int c;
     *number = 0;
@@ -19,18 +27,17 @@ void fastinput(int *number) {
     // Keep on extracting characters if they are integers
     // i.e ASCII Value lies from '0'(48) to '9' (57)
     for (; (c > 47 && c < 58); c = std::getchar())
-        *number = *number *10 + c - 48;
+        *number = *number * 10 + c - 48;
 
     // if scanned input has a negative sign, negate the
     // value of the input number
-    if (negative)
-        *(number) *= -1;
+    if (negative) *(number) *= -1;
 }
 
-// Function Call
+/** Main function */
 int main() {
     int number;
     fastinput(&number);
-    std::cout << number << "\n";
+    std::cout << number << std::endl;
     return 0;
 }

From 28ffd29d4c5b5ccbfb19def617da359d551397e7 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:51:39 -0400
Subject: [PATCH 149/290] update documentation for gcd_of_n_numbers

---
 others/gcd_of_n_numbers.cpp | 43 ++++++++++++++++++++++++++-----------
 1 file changed, 31 insertions(+), 12 deletions(-)

diff --git a/others/gcd_of_n_numbers.cpp b/others/gcd_of_n_numbers.cpp
index 37e82173a..0a187f6d0 100644
--- a/others/gcd_of_n_numbers.cpp
+++ b/others/gcd_of_n_numbers.cpp
@@ -1,23 +1,42 @@
-// This program aims at calculating the GCD of n numbers by division method
+/**
+ * @file
+ * @brief This program aims at calculating the GCD of n numbers by division
+ * method
+ *
+ * @see ../math/greatest_common_divisor.cpp
+ * greatest_common_divisor_euclidean.cpp
+ */
 #include <iostream>
 
-int main() {
-    int n;
-    std::cout << "Enter value of n:" << std::endl;
-    std::cin >> n;
-    int *a = new int[n];
-    int i, j, gcd;
-    std::cout << "Enter the n numbers:" << std::endl;
-    for (i = 0; i < n; i++) std::cin >> a[i];
-    j = 1;  // to access all elements of the array starting from 1
-    gcd = a[0];
+/** Compute GCD using division algorithm
+ *
+ * @param[in] a array of integers to compute GCD for
+ * @param[in] n number of integers in array `a`
+ */
+int gcd(int *a, int n) {
+    int j = 1;  // to access all elements of the array starting from 1
+    int gcd = a[0];
     while (j < n) {
         if (a[j] % gcd == 0)  // value of gcd is as needed so far
             j++;              // so we check for next element
         else
             gcd = a[j] % gcd;  // calculating GCD by division method
     }
-    std::cout << "GCD of entered n numbers:" << gcd;
+    return gcd;
+}
+
+/** Main function */
+int main() {
+    int n;
+    std::cout << "Enter value of n:" << std::endl;
+    std::cin >> n;
+    int *a = new int[n];
+    int i;
+    std::cout << "Enter the n numbers:" << std::endl;
+    for (i = 0; i < n; i++) std::cin >> a[i];
+
+    std::cout << "GCD of entered n numbers:" << gcd(a, n) << std::endl;
+
     delete[] a;
     return 0;
 }

From 21c963c2f505e843f69be8799424c7744604c0c2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:52:07 -0400
Subject: [PATCH 150/290] move the gcd_of_n_numbers to math folder along with
 all other GCD algorithms

---
 {others => math}/gcd_of_n_numbers.cpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {others => math}/gcd_of_n_numbers.cpp (100%)

diff --git a/others/gcd_of_n_numbers.cpp b/math/gcd_of_n_numbers.cpp
similarity index 100%
rename from others/gcd_of_n_numbers.cpp
rename to math/gcd_of_n_numbers.cpp

From 0a58f8f08fd3eb4cfbcd079ab80a7a64b137b91a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:55:09 -0400
Subject: [PATCH 151/290] include see-also for all gcd algos

---
 math/gcd_iterative_euclidean.cpp |  2 +-
 math/gcd_of_n_numbers.cpp        |  3 +--
 math/gcd_recursive_euclidean.cpp | 14 +++++++++-----
 3 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/math/gcd_iterative_euclidean.cpp b/math/gcd_iterative_euclidean.cpp
index 61fb640a3..2c0651ad7 100644
--- a/math/gcd_iterative_euclidean.cpp
+++ b/math/gcd_iterative_euclidean.cpp
@@ -4,7 +4,7 @@
  * *iterative form* of
  * [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm)
  *
- * @see gcd_recursive_euclidean.cpp
+ * @see gcd_recursive_euclidean.cpp, gcd_of_n_numbers.cpp
  */
 #include <iostream>
 #include <stdexcept>
diff --git a/math/gcd_of_n_numbers.cpp b/math/gcd_of_n_numbers.cpp
index 0a187f6d0..92968ff12 100644
--- a/math/gcd_of_n_numbers.cpp
+++ b/math/gcd_of_n_numbers.cpp
@@ -3,8 +3,7 @@
  * @brief This program aims at calculating the GCD of n numbers by division
  * method
  *
- * @see ../math/greatest_common_divisor.cpp
- * greatest_common_divisor_euclidean.cpp
+ * @see gcd_iterative_euclidean.cpp, gcd_recursive_euclidean.cpp
  */
 #include <iostream>
 
diff --git a/math/gcd_recursive_euclidean.cpp b/math/gcd_recursive_euclidean.cpp
index 3a1ca6e66..2a3d2183c 100644
--- a/math/gcd_recursive_euclidean.cpp
+++ b/math/gcd_recursive_euclidean.cpp
@@ -4,7 +4,7 @@
  * *recursive form* of
  * [Euclidean algorithm](https://en.wikipedia.org/wiki/Euclidean_algorithm)
  *
- * @see gcd_iterative_euclidean.cpp
+ * @see gcd_iterative_euclidean.cpp, gcd_of_n_numbers.cpp
  */
 #include <iostream>
 
@@ -21,14 +21,18 @@ int gcd(int num1, int num2) {
     }
 
     // Everything divides 0
-    if (num1 == 0) return num2;
-    if (num2 == 0) return num1;
+    if (num1 == 0)
+        return num2;
+    if (num2 == 0)
+        return num1;
 
     // base case
-    if (num1 == num2) return num1;
+    if (num1 == num2)
+        return num1;
 
     // a is greater
-    if (num1 > num2) return gcd(num1 - num2, num2);
+    if (num1 > num2)
+        return gcd(num1 - num2, num2);
     return gcd(num1, num2 - num1);
 }
 

From a53ba4b8569e8cbeb9b8f5522b2a32bdac9d12dc Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 18:58:21 -0400
Subject: [PATCH 152/290] document fibonacci fast & link to fibonacci numbers

---
 math/fibonacci.cpp         |  2 +-
 others/fibonacci_fast.cpp  | 39 ++++++++++++++++++++++++++------------
 others/fibonacci_large.cpp |  2 +-
 3 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index 034b91970..da7736564 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -6,7 +6,7 @@
  * integer as input.
  * \f[\text{fib}(n) = \text{fib}(n-1) + \text{fib}(n-2)\f]
  *
- * @see fibonacci_large.cpp
+ * @see fibonacci_large.cpp, fibonacci_fast.cpp
  */
 #include <cassert>
 #include <iostream>
diff --git a/others/fibonacci_fast.cpp b/others/fibonacci_fast.cpp
index a0b83b640..dc59742b8 100644
--- a/others/fibonacci_fast.cpp
+++ b/others/fibonacci_fast.cpp
@@ -1,25 +1,39 @@
-// An efficient way to calculate nth fibonacci number faster and simpler than
-// O(nlogn) method of matrix exponentiation This works by using both recursion
-// and dynamic programming. as 93rd fibonacci exceeds 19 digits, which cannot be
-// stored in a single long long variable, we can only use it till 92nd fibonacci
-// we can use it for 10000th fibonacci etc, if we implement bigintegers.
-// This algorithm works with the fact that nth fibonacci can easily found if we
-// have already found n/2th or (n+1)/2th fibonacci It is a property of fibonacci
-// similar to matrix exponentiation.
+/**
+ * @file
+ * @brief Faster computation of Fibonacci series
+ *
+ * An efficient way to calculate nth fibonacci number faster and simpler than
+ * \f$O(n\log n)\f$ method of matrix exponentiation This works by using both
+ * recursion and dynamic programming. as 93rd fibonacci exceeds 19 digits, which
+ * cannot be stored in a single long long variable, we can only use it till 92nd
+ * fibonacci we can use it for 10000th fibonacci etc, if we implement
+ * bigintegers. This algorithm works with the fact that nth fibonacci can easily
+ * found if we have already found n/2th or (n+1)/2th fibonacci It is a property
+ * of fibonacci similar to matrix exponentiation.
+ *
+ * @see fibonacci_large.cpp, fibonacci.cpp
+ */
 
 #include <cinttypes>
 #include <cstdio>
 #include <iostream>
 
+/** maximum number that can be computed - The result after 93 cannot be stored
+ * in a `uint64_t` data type. */
 const uint64_t MAX = 93;
 
+/** Array of computed fibonacci numbers */
 uint64_t f[MAX] = {0};
 
+/** Algorithm */
 uint64_t fib(uint64_t n) {
-    if (n == 0) return 0;
-    if (n == 1 || n == 2) return (f[n] = 1);
+    if (n == 0)
+        return 0;
+    if (n == 1 || n == 2)
+        return (f[n] = 1);
 
-    if (f[n]) return f[n];
+    if (f[n])
+        return f[n];
 
     uint64_t k = (n % 2 != 0) ? (n + 1) / 2 : n / 2;
 
@@ -28,10 +42,11 @@ uint64_t fib(uint64_t n) {
     return f[n];
 }
 
+/** Main function */
 int main() {
     // Main Function
     for (uint64_t i = 1; i < 93; i++) {
-        std::cout << i << " th fibonacci number is " << fib(i) << "\n";
+        std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
     }
     return 0;
 }
diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index 6b556066a..4545fdc9f 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -7,7 +7,7 @@
  * Took 0.608246 seconds to compute 50,000^th Fibonacci
  * number that contains 10450 digits!
  *
- * @see fibonacci.cpp
+ * @see fibonacci.cpp, fibonacci_fast.cpp
  */
 
 #include <cinttypes>

From e480c049be85f5250e6bdcf89e7d2fea26c3156d Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 19:00:20 -0400
Subject: [PATCH 153/290] mode math algorithms to math folder

---
 {others => math}/fibonacci_fast.cpp  | 0
 {others => math}/fibonacci_large.cpp | 0
 {others => math}/large_factorial.cpp | 0
 {others => math}/large_number.h      | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 rename {others => math}/fibonacci_fast.cpp (100%)
 rename {others => math}/fibonacci_large.cpp (100%)
 rename {others => math}/large_factorial.cpp (100%)
 rename {others => math}/large_number.h (100%)

diff --git a/others/fibonacci_fast.cpp b/math/fibonacci_fast.cpp
similarity index 100%
rename from others/fibonacci_fast.cpp
rename to math/fibonacci_fast.cpp
diff --git a/others/fibonacci_large.cpp b/math/fibonacci_large.cpp
similarity index 100%
rename from others/fibonacci_large.cpp
rename to math/fibonacci_large.cpp
diff --git a/others/large_factorial.cpp b/math/large_factorial.cpp
similarity index 100%
rename from others/large_factorial.cpp
rename to math/large_factorial.cpp
diff --git a/others/large_number.h b/math/large_number.h
similarity index 100%
rename from others/large_number.h
rename to math/large_number.h

From cd43716d892ba33bc92f058b256c6465f1552e10 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Wed, 27 May 2020 20:21:09 -0400
Subject: [PATCH 154/290] doxygen TAGFILE to provide more torough documentation
 for the STL classes from https://cppreference.com Based out of SO:
 https://stackoverflow.com/questions/43099899/can-i-make-doxygen-resolve-refs-to-c-standard-library-functions

---
 CMakeLists.txt                       |     5 +-
 doc/cppreference-doxygen-web.tag.xml | 35489 +++++++++++++++++++++++++
 2 files changed, 35493 insertions(+), 1 deletion(-)
 create mode 100644 doc/cppreference-doxygen-web.tag.xml

diff --git a/CMakeLists.txt b/CMakeLists.txt
index aafeb69d3..c072de6e0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,13 +24,16 @@ find_package(Doxygen OPTIONAL_COMPONENTS dot dia)
 if(DOXYGEN_FOUND)
     set(DOXYGEN_GENERATE_MAN NO)
     set(DOXYGEN_USE_MATHJAX YES)
-    set(DOXYGEN_FILE_PATTERNS *.cpp *.h *.hpp *.md)
     set(DOXYGEN_GENERATE_HTML YES)
+    set(DOXYGEN_EXTRACT_STATIC YES)
     set(DOXYGEN_INLINE_SOURCES YES)
     set(DOXYGEN_CREATE_SUBDIRS YES)
+    set(DOXYGEN_EXTRACT_PRIVATE YES)
     set(DOCYGEN_GENERATE_TREEVIEW YES)
     set(DOXYGEN_STRIP_CODE_COMMENTS NO)
     set(DOXYGEN_BUILTIN_STL_SUPPORT YES)
+    set(DOXYGEN_FILE_PATTERNS *.cpp *.h *.hpp *.md)
+    set(DOXYGEN_TAGFILES "doc/cppreference-doxygen-web.tag.xml=http://en.cppreference.com/w/")
     if(MSVC)
         set(DOXYGEN_CPP_CLI_SUPPORT YES)
     endif()
diff --git a/doc/cppreference-doxygen-web.tag.xml b/doc/cppreference-doxygen-web.tag.xml
new file mode 100644
index 000000000..ea8388b8b
--- /dev/null
+++ b/doc/cppreference-doxygen-web.tag.xml
@@ -0,0 +1,35489 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<tagfile>
+  <compound kind="namespace">
+    <name>std</name>
+    <filename></filename>
+    <class kind="class">std::is_function</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_and_explicit</name>
+      <anchorfile>cpp/atomic/atomic_fetch_sub</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_xor_explicit</name>
+      <anchorfile>cpp/atomic/atomic_fetch_xor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_unexpected</name>
+      <anchorfile>cpp/error/set_unexpected</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::input_iterator_tag</class>
+    <class kind="class">std::logical_and</class>
+    <class kind="class">std::is_integral</class>
+    <class kind="class">std::money_get</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fputs</name>
+      <anchorfile>cpp/io/c/fputs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ofstream</class>
+    <class kind="class">std::ratio_subtract</class>
+    <member kind="function">
+      <type>T</type>
+      <name>modf</name>
+      <anchorfile>cpp/numeric/math/modf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::size_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>not2</name>
+      <anchorfile>cpp/utility/functional/not2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strlen</name>
+      <anchorfile>cpp/string/byte/strlen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exp2</name>
+      <anchorfile>cpp/numeric/math/exp2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ctype_byname</class>
+    <class kind="class">std::wcout</class>
+    <member kind="function">
+      <type>T</type>
+      <name>setiosflags</name>
+      <anchorfile>cpp/io/manip/setiosflags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>adjacent_difference</name>
+      <anchorfile>cpp/algorithm/adjacent_difference</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cos</name>
+      <anchorfile>cpp/numeric/math/cos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fwscanf</name>
+      <anchorfile>cpp/io/c/fwscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_init</name>
+      <anchorfile>cpp/atomic/atomic_init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::fstream</class>
+    <class kind="class">std::valarray</class>
+    <class kind="class">std::ratio_greater_equal</class>
+    <member kind="function">
+      <type>T</type>
+      <name>forward_as_tuple</name>
+      <anchorfile>cpp/utility/tuple/forward_as_tuple</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::remove_extent</class>
+    <class kind="class">std::ratio_greater</class>
+    <member kind="function">
+      <type>T</type>
+      <name>abort</name>
+      <anchorfile>cpp/utility/program/abort</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsncmp</name>
+      <anchorfile>cpp/string/wide/wcsncmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::intptr_t</class>
+    <class kind="class">std::regex_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>set_intersection</name>
+      <anchorfile>cpp/algorithm/set_intersection</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::lock_guard</class>
+    <class kind="class">std::wbuffer_convert</class>
+    <class kind="class">std::modulus</class>
+    <class kind="class">std::ratio_divide</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_signal_fence</name>
+      <anchorfile>cpp/atomic/atomic_signal_fence</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>llabs</name>
+      <anchorfile>cpp/numeric/math/abs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>make_move_iterator</name>
+      <anchorfile>cpp/iterator/make_move_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostreambuf_iterator</class>
+    <class kind="class">std::dynarray</class>
+    <class kind="class">std::is_nothrow_move_constructible</class>
+    <class kind="class">std::vector</class>
+    <member kind="function">
+      <type>T</type>
+      <name>scanf</name>
+      <anchorfile>cpp/io/c/fscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::match_results</class>
+    <class kind="class">std::back_insert_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>nextafter</name>
+      <anchorfile>cpp/numeric/math/nextafter</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::iterator</class>
+    <class kind="class">std::int8_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>stol</name>
+      <anchorfile>cpp/string/basic_string/stol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strcspn</name>
+      <anchorfile>cpp/string/byte/strcspn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ungetwc</name>
+      <anchorfile>cpp/io/c/ungetwc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>transform</name>
+      <anchorfile>cpp/algorithm/transform</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::student_t_distribution</class>
+    <class kind="class">std::mt19937_64</class>
+    <class kind="class">std::runtime_error</class>
+    <member kind="function">
+      <type>T</type>
+      <name>putc</name>
+      <anchorfile>cpp/io/c/fputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iswdigit</name>
+      <anchorfile>cpp/string/wide/iswdigit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ranlux24_base</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rint</name>
+      <anchorfile>cpp/numeric/math/rint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::allocator_traits</class>
+    <member kind="function">
+      <type>T</type>
+      <name>memset</name>
+      <anchorfile>cpp/string/byte/memset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isgraph</name>
+      <anchorfile>cpp/string/byte/isgraph</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt</class>
+    <class kind="class">std::ratio_less_equal</class>
+    <member kind="function">
+      <type>T</type>
+      <name>replace_copy_if</name>
+      <anchorfile>cpp/algorithm/replace_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>scalbn</name>
+      <anchorfile>cpp/numeric/math/scalbn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::condition_variable_any</class>
+    <member kind="function">
+      <type>T</type>
+      <name>partial_sort_copy</name>
+      <anchorfile>cpp/algorithm/partial_sort_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::deca</class>
+    <class kind="class">std::extreme_value_distribution</class>
+    <class kind="class">std::cout</class>
+    <class kind="class">std::decay</class>
+    <class kind="class">std::is_trivially_move_assignable</class>
+    <class kind="class">std::adopt_lock_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>make_exception_ptr</name>
+      <anchorfile>cpp/error/make_exception_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wcerr</class>
+    <member kind="function">
+      <type>T</type>
+      <name>frexp</name>
+      <anchorfile>cpp/numeric/math/frexp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::lognormal_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>isxdigit</name>
+      <anchorfile>cpp/string/byte/isxdigit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wclog</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_exchange_explicit</name>
+      <anchorfile>cpp/atomic/atomic_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wprintf</name>
+      <anchorfile>cpp/io/c/fwprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::char_traits</class>
+    <class kind="class">std::remove_reference</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fdim</name>
+      <anchorfile>cpp/numeric/math/fdim</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::num_get</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wctype</name>
+      <anchorfile>cpp/string/wide/wctype</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_pointer</class>
+    <member kind="function">
+      <type>T</type>
+      <name>mbrtoc32</name>
+      <anchorfile>cpp/string/multibyte/mbrtoc32</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setw</name>
+      <anchorfile>cpp/io/manip/setw</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_temporary_buffer</name>
+      <anchorfile>cpp/memory/get_temporary_buffer</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fmax</name>
+      <anchorfile>cpp/numeric/math/fmax</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::multiset</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_thread_fence</name>
+      <anchorfile>cpp/atomic/atomic_thread_fence</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_exchange</name>
+      <anchorfile>cpp/atomic/atomic_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::weak_ptr</class>
+    <class kind="class">std::bidirectional_iterator_tag</class>
+    <class kind="class">std::wstring_convert</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fgetwc</name>
+      <anchorfile>cpp/io/c/fgetwc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swprintf</name>
+      <anchorfile>cpp/io/c/fwprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>prev_permutation</name>
+      <anchorfile>cpp/algorithm/prev_permutation</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::greater_equal</class>
+    <class kind="class">std::is_trivially_constructible</class>
+    <member kind="function">
+      <type>T</type>
+      <name>max_element</name>
+      <anchorfile>cpp/algorithm/max_element</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::string</class>
+    <class kind="class">std::discrete_distribution</class>
+    <class kind="class">std::wostream</class>
+    <class kind="class">std::is_polymorphic</class>
+    <member kind="function">
+      <type>T</type>
+      <name>set_symmetric_difference</name>
+      <anchorfile>cpp/algorithm/set_symmetric_difference</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcscpy</name>
+      <anchorfile>cpp/string/wide/wcscpy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>const_pointer_cast</name>
+      <anchorfile>cpp/memory/shared_ptr/pointer_cast</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>minmax_element</name>
+      <anchorfile>cpp/algorithm/minmax_element</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstok</name>
+      <anchorfile>cpp/string/wide/wcstok</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ref</name>
+      <anchorfile>cpp/utility/functional/ref</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::reverse_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>feupdateenv</name>
+      <anchorfile>cpp/numeric/fenv/feupdateenv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bad_array_new_length</class>
+    <member kind="function">
+      <type>T</type>
+      <name>endl</name>
+      <anchorfile>cpp/io/manip/endl</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/iterator/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::condition_variable</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wmemmove</name>
+      <anchorfile>cpp/string/wide/wmemmove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fmin</name>
+      <anchorfile>cpp/numeric/math/fmin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uninitialized_fill_n</name>
+      <anchorfile>cpp/memory/uninitialized_fill_n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ranlux48</class>
+    <member kind="function">
+      <type>T</type>
+      <name>nouppercase</name>
+      <anchorfile>cpp/io/manip/uppercase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>noshowpos</name>
+      <anchorfile>cpp/io/manip/showpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ctime</name>
+      <anchorfile>cpp/chrono/c/ctime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wmemset</name>
+      <anchorfile>cpp/string/wide/wmemset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::unexpected_handler</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswpunct</name>
+      <anchorfile>cpp/string/wide/iswpunct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::piecewise_constant_distribution</class>
+    <class kind="class">std::codecvt_base</class>
+    <class kind="class">std::set</class>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_heap</name>
+      <anchorfile>cpp/algorithm/pop_heap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sprintf</name>
+      <anchorfile>cpp/io/c/fprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fixed</name>
+      <anchorfile>cpp/io/manip/fixed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>make_shared</name>
+      <anchorfile>cpp/memory/shared_ptr/make_shared</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::forward_iterator_tag</class>
+    <class kind="class">std::codecvt_byname</class>
+    <class kind="class">std::pointer_safety</class>
+    <class kind="class">std::uint_least64_t</class>
+    <class kind="class">std::placeholders</class>
+    <class kind="class">std::nothrow_t</class>
+    <class kind="class">std::is_nothrow_copy_assignable</class>
+    <class kind="class">std::is_same</class>
+    <member kind="function">
+      <type>T</type>
+      <name>make_heap</name>
+      <anchorfile>cpp/algorithm/make_heap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fmod</name>
+      <anchorfile>cpp/numeric/math/fmod</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::unique_lock</class>
+    <class kind="class">std::basic_ostringstream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atol</name>
+      <anchorfile>cpp/string/byte/atoi</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_error_code_enum</class>
+    <class kind="class">std::time_put_byname</class>
+    <member kind="function">
+      <type>T</type>
+      <name>uninitialized_copy</name>
+      <anchorfile>cpp/memory/uninitialized_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_get</class>
+    <member kind="function">
+      <type>T</type>
+      <name>dynamic_pointer_cast</name>
+      <anchorfile>cpp/memory/shared_ptr/pointer_cast</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_union</name>
+      <anchorfile>cpp/algorithm/set_union</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::regex</class>
+    <class kind="class">std::cin</class>
+    <member kind="function">
+      <type>T</type>
+      <name>hexfloat</name>
+      <anchorfile>cpp/io/manip/fixed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vswprintf</name>
+      <anchorfile>cpp/io/c/vfwprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>asctime</name>
+      <anchorfile>cpp/chrono/c/asctime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::unordered_map</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswspace</name>
+      <anchorfile>cpp/string/wide/iswspace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::initializer_list</class>
+    <member kind="function">
+      <type>T</type>
+      <name>nan</name>
+      <anchorfile>cpp/numeric/math/nan</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sort</name>
+      <anchorfile>cpp/algorithm/sort</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>quick_exit</name>
+      <anchorfile>cpp/utility/program/quick_exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_const</class>
+    <member kind="function">
+      <type>T</type>
+      <name>log10</name>
+      <anchorfile>cpp/numeric/math/log10</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_regex</class>
+    <member kind="function">
+      <type>T</type>
+      <name>mbstowcs</name>
+      <anchorfile>cpp/string/multibyte/mbstowcs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isspace</name>
+      <anchorfile>cpp/string/byte/isspace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::poisson_distribution</class>
+    <class kind="class">std::bad_typeid</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strncat</name>
+      <anchorfile>cpp/string/byte/strncat</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::less_equal</class>
+    <member kind="function">
+      <type>T</type>
+      <name>isinf</name>
+      <anchorfile>cpp/numeric/math/isinf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atof</name>
+      <anchorfile>cpp/string/byte/atof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::sig_atomic_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>erf</name>
+      <anchorfile>cpp/numeric/math/erf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_sorted_until</name>
+      <anchorfile>cpp/algorithm/is_sorted_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbrt</name>
+      <anchorfile>cpp/numeric/math/cbrt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>log1p</name>
+      <anchorfile>cpp/numeric/math/log1p</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>return_temporary_buffer</name>
+      <anchorfile>cpp/memory/return_temporary_buffer</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mbsrtowcs</name>
+      <anchorfile>cpp/string/multibyte/mbsrtowcs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>feraiseexcept</name>
+      <anchorfile>cpp/numeric/fenv/feraiseexcept</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fseek</name>
+      <anchorfile>cpp/io/c/fseek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::make_unsigned</class>
+    <class kind="class">std::basic_filebuf</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_or_explicit</name>
+      <anchorfile>cpp/atomic/atomic_fetch_or</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::logical_or</class>
+    <member kind="function">
+      <type>T</type>
+      <name>log</name>
+      <anchorfile>cpp/numeric/math/log</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putchar</name>
+      <anchorfile>cpp/io/c/putchar</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>make_tuple</name>
+      <anchorfile>cpp/utility/tuple/make_tuple</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>expm1</name>
+      <anchorfile>cpp/numeric/math/expm1</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstringbuf</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fma</name>
+      <anchorfile>cpp/numeric/math/fma</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::kilo</class>
+    <class kind="class">std::bernoulli_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>remove_copy_if</name>
+      <anchorfile>cpp/algorithm/remove_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showpoint</name>
+      <anchorfile>cpp/io/manip/showpoint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::int16_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fscanf</name>
+      <anchorfile>cpp/io/c/fscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>stable_partition</name>
+      <anchorfile>cpp/algorithm/stable_partition</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ios</class>
+    <class kind="class">std::int32_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fill_n</name>
+      <anchorfile>cpp/algorithm/fill_n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_rvalue_reference</class>
+    <member kind="function">
+      <type>T</type>
+      <name>remove_copy</name>
+      <anchorfile>cpp/algorithm/remove_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_compare_exchange_strong_explicit</name>
+      <anchorfile>cpp/atomic/atomic_compare_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::integral_constant</class>
+    <class kind="class">std::wsmatch</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wctomb</name>
+      <anchorfile>cpp/string/multibyte/wctomb</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fgets</name>
+      <anchorfile>cpp/io/c/fgets</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>remainder</name>
+      <anchorfile>cpp/numeric/math/remainder</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::cerr</class>
+    <class kind="class">std::codecvt_utf8</class>
+    <member kind="function">
+      <type>T</type>
+      <name>allocate_shared</name>
+      <anchorfile>cpp/memory/shared_ptr/allocate_shared</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ratio_add</class>
+    <member kind="function">
+      <type>T</type>
+      <name>unique</name>
+      <anchorfile>cpp/algorithm/unique</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_trivially_move_constructible</class>
+    <member kind="function">
+      <type>T</type>
+      <name>includes</name>
+      <anchorfile>cpp/algorithm/includes</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iswalnum</name>
+      <anchorfile>cpp/string/wide/iswalnum</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wcsub_match</class>
+    <member kind="function">
+      <type>T</type>
+      <name>exit</name>
+      <anchorfile>cpp/utility/program/exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put_time</name>
+      <anchorfile>cpp/io/manip/put_time</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_string</name>
+      <anchorfile>cpp/string/basic_string/to_string</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_heap_until</name>
+      <anchorfile>cpp/algorithm/is_heap_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_member_pointer</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstold</name>
+      <anchorfile>cpp/string/wide/wcstof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstreampos</class>
+    <class kind="class">std::uint_least16_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>stold</name>
+      <anchorfile>cpp/string/basic_string/stof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ftell</name>
+      <anchorfile>cpp/io/c/ftell</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::tuple</class>
+    <member kind="function">
+      <type>T</type>
+      <name>copy_backward</name>
+      <anchorfile>cpp/algorithm/copy_backward</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstoll</name>
+      <anchorfile>cpp/string/wide/wcstol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>perror</name>
+      <anchorfile>cpp/io/c/perror</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vwscanf</name>
+      <anchorfile>cpp/io/c/vfwscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>stable_sort</name>
+      <anchorfile>cpp/algorithm/stable_sort</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::make_signed</class>
+    <member kind="function">
+      <type>T</type>
+      <name>generic_category</name>
+      <anchorfile>cpp/error/generic_category</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>abs(int)</name>
+      <anchorfile>cpp/numeric/math/abs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fgetws</name>
+      <anchorfile>cpp/io/c/fgetws</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::logic_error</class>
+    <class kind="class">std::sregex_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>showpos</name>
+      <anchorfile>cpp/io/manip/showpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::int_least64_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>exp</name>
+      <anchorfile>cpp/numeric/math/exp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::binary_negate</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/algorithm/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isalpha</name>
+      <anchorfile>cpp/string/byte/isalpha</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::discard_block_engine</class>
+    <class kind="class">std::is_trivially_assignable</class>
+    <class kind="class">std::add_cv</class>
+    <member kind="function">
+      <type>T</type>
+      <name>lgamma</name>
+      <anchorfile>cpp/numeric/math/lgamma</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::pico</class>
+    <class kind="class">std::iterator_traits</class>
+    <class kind="class">std::is_trivially_default_constructible</class>
+    <member kind="function">
+      <type>T</type>
+      <name>feclearexcept</name>
+      <anchorfile>cpp/numeric/fenv/feclearexcept</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsncpy</name>
+      <anchorfile>cpp/string/wide/wcsncpy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>undeclare_reachable</name>
+      <anchorfile>cpp/memory/gc/undeclare_reachable</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::shared_ptr</class>
+    <member kind="function">
+      <type>T</type>
+      <name>oct</name>
+      <anchorfile>cpp/io/manip/hex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bad_alloc</class>
+    <class kind="class">std::ostringstream</class>
+    <class kind="class">std::basic_fstream</class>
+    <class kind="class">std::stringbuf</class>
+    <class kind="class">std::exponential_distribution</class>
+    <class kind="class">std::uint32_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strspn</name>
+      <anchorfile>cpp/string/byte/strspn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wcregex_iterator</class>
+    <class kind="class">std::bad_function_call</class>
+    <member kind="function">
+      <type>T</type>
+      <name>realloc</name>
+      <anchorfile>cpp/memory/c/realloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy</name>
+      <anchorfile>cpp/algorithm/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>binary_search</name>
+      <anchorfile>cpp/algorithm/binary_search</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>system_category</name>
+      <anchorfile>cpp/error/system_category</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mbrtowc</name>
+      <anchorfile>cpp/string/multibyte/mbrtowc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::false_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strtof</name>
+      <anchorfile>cpp/string/byte/strtof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mem_fn</name>
+      <anchorfile>cpp/utility/functional/mem_fn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wregex</class>
+    <member kind="function">
+      <type>T</type>
+      <name>distance</name>
+      <anchorfile>cpp/iterator/distance</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strcmp</name>
+      <anchorfile>cpp/string/byte/strcmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tmpfile</name>
+      <anchorfile>cpp/io/c/tmpfile</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hypot</name>
+      <anchorfile>cpp/numeric/math/hypot</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getenv</name>
+      <anchorfile>cpp/utility/program/getenv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strrchr</name>
+      <anchorfile>cpp/string/byte/strrchr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/algorithm/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uint_least8_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>tan</name>
+      <anchorfile>cpp/numeric/math/tan</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strftime</name>
+      <anchorfile>cpp/chrono/c/strftime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uniform_real_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>stod</name>
+      <anchorfile>cpp/string/basic_string/stof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>towupper</name>
+      <anchorfile>cpp/string/wide/towupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::smatch</class>
+    <class kind="class">std::cregex_token_iterator</class>
+    <class kind="class">std::range_error</class>
+    <class kind="class">std::is_assignable</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atoll</name>
+      <anchorfile>cpp/string/byte/atoi</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_copy_assignable</class>
+    <class kind="class">std::invalid_argument</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_store</name>
+      <anchorfile>cpp/atomic/atomic_store</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_unsigned</class>
+    <class kind="class">std::jmp_buf</class>
+    <class kind="class">std::is_class</class>
+    <class kind="class">std::geometric_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>stoi</name>
+      <anchorfile>cpp/string/basic_string/stol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rethrow_exception</name>
+      <anchorfile>cpp/error/rethrow_exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uint_fast8_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>sin</name>
+      <anchorfile>cpp/numeric/math/sin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_sub_explicit</name>
+      <anchorfile>cpp/atomic/atomic_fetch_sub</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unexpected</name>
+      <anchorfile>cpp/error/unexpected</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mbtowc</name>
+      <anchorfile>cpp/string/multibyte/mbtowc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::mersenne_twister_engine</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get_time</name>
+      <anchorfile>cpp/io/manip/get_time</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>partition</name>
+      <anchorfile>cpp/algorithm/partition</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>next</name>
+      <anchorfile>cpp/iterator/next</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_arithmetic</class>
+    <class kind="class">std::negate</class>
+    <class kind="class">std::try_to_lock_t</class>
+    <class kind="class">std::wfilebuf</class>
+    <class kind="class">std::is_compound</class>
+    <class kind="class">std::iostream</class>
+    <class kind="class">std::is_object</class>
+    <member kind="function">
+      <type>T</type>
+      <name>isfinite</name>
+      <anchorfile>cpp/numeric/math/isfinite</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>boolalpha</name>
+      <anchorfile>cpp/io/manip/boolalpha</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fetestexcept</name>
+      <anchorfile>cpp/numeric/fenv/fetestexcept</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mbrlen</name>
+      <anchorfile>cpp/string/multibyte/mbrlen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::recursive_mutex</class>
+    <class kind="class">std::is_copy_constructible</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswgraph</name>
+      <anchorfile>cpp/string/wide/iswgraph</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf8_utf16</class>
+    <class kind="class">std::not_equal_to</class>
+    <class kind="class">std::is_destructible</class>
+    <class kind="class">std::int_fast32_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>time</name>
+      <anchorfile>cpp/chrono/c/time</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_compare_exchange_strong</name>
+      <anchorfile>cpp/atomic/atomic_compare_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::rank</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcschr</name>
+      <anchorfile>cpp/string/wide/wcschr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uppercase</name>
+      <anchorfile>cpp/io/manip/uppercase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::milli</class>
+    <class kind="class">std::deci</class>
+    <member kind="function">
+      <type>T</type>
+      <name>lower_bound</name>
+      <anchorfile>cpp/algorithm/lower_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::add_lvalue_reference</class>
+    <class kind="class">std::is_bind_expression</class>
+    <class kind="class">std::ios_base</class>
+    <member kind="function">
+      <type>T</type>
+      <name>copy_if</name>
+      <anchorfile>cpp/algorithm/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ratio_less</class>
+    <class kind="class">std::int64_t</class>
+    <class kind="class">std::nullptr_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>isnan</name>
+      <anchorfile>cpp/numeric/math/isnan</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>has_facet</name>
+      <anchorfile>cpp/locale/has_facet</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>kill_dependency</name>
+      <anchorfile>cpp/atomic/kill_dependency</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uninitialized_copy_n</name>
+      <anchorfile>cpp/memory/uninitialized_copy_n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::stack</class>
+    <member kind="function">
+      <type>T</type>
+      <name>feholdexcept</name>
+      <anchorfile>cpp/numeric/fenv/feholdexcept</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>div</name>
+      <anchorfile>cpp/numeric/math/div</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at_quick_exit</name>
+      <anchorfile>cpp/utility/program/at_quick_exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uint_fast64_t</class>
+    <class kind="class">std::is_reference</class>
+    <class kind="class">std::ratio</class>
+    <class kind="class">std::shared_future</class>
+    <class kind="class">std::u16streampos</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcspbrk</name>
+      <anchorfile>cpp/string/wide/wcspbrk</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>search</name>
+      <anchorfile>cpp/algorithm/search</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistream</class>
+    <class kind="class">std::aligned_storage</class>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_of</name>
+      <anchorfile>cpp/algorithm/find_first_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iota</name>
+      <anchorfile>cpp/algorithm/iota</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstreambuf</class>
+    <member kind="function">
+      <type>T</type>
+      <name>declare_reachable</name>
+      <anchorfile>cpp/memory/gc/declare_reachable</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_compare_exchange_weak</name>
+      <anchorfile>cpp/atomic/atomic_compare_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::binary_function</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strtod</name>
+      <anchorfile>cpp/string/byte/strtof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>accumulate</name>
+      <anchorfile>cpp/algorithm/accumulate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsrchr</name>
+      <anchorfile>cpp/string/wide/wcsrchr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::out_of_range</class>
+    <member kind="function">
+      <type>T</type>
+      <name>min_element</name>
+      <anchorfile>cpp/algorithm/min_element</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::independent_bits_engine</class>
+    <member kind="function">
+      <type>T</type>
+      <name>clearerr</name>
+      <anchorfile>cpp/io/c/clearerr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>random_shuffle</name>
+      <anchorfile>cpp/algorithm/random_shuffle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::stringstream</class>
+    <class kind="class">std::tera</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswalpha</name>
+      <anchorfile>cpp/string/wide/iswalpha</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::recursive_timed_mutex</class>
+    <class kind="class">std::nano</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_and</name>
+      <anchorfile>cpp/atomic/atomic_fetch_sub</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wmemchr</name>
+      <anchorfile>cpp/string/wide/wmemchr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::unordered_multimap</class>
+    <class kind="class">std::normal_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>bsearch</name>
+      <anchorfile>cpp/algorithm/bsearch</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ilogb</name>
+      <anchorfile>cpp/numeric/math/ilogb</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::minstd_rand</class>
+    <class kind="class">std::is_signed</class>
+    <member kind="function">
+      <type>T</type>
+      <name>unique_copy</name>
+      <anchorfile>cpp/algorithm/unique_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>_Exit</name>
+      <anchorfile>cpp/utility/program/_Exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/utility/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_end</name>
+      <anchorfile>cpp/algorithm/find_end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_move_constructible</class>
+    <class kind="class">std::unique_ptr</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fesetexceptflag</name>
+      <anchorfile>cpp/numeric/fenv/feexceptflag</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_nothrow_copy_constructible</class>
+    <class kind="class">std::forward_list</class>
+    <class kind="class">std::errc</class>
+    <class kind="class">std::lconv</class>
+    <member kind="function">
+      <type>T</type>
+      <name>nth_element</name>
+      <anchorfile>cpp/algorithm/nth_element</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gets</name>
+      <anchorfile>cpp/io/c/gets</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lexicographical_compare</name>
+      <anchorfile>cpp/algorithm/lexicographical_compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>nearbyint</name>
+      <anchorfile>cpp/numeric/math/nearbyint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::strstreambuf</class>
+    <class kind="class">std::locale</class>
+    <class kind="class">std::equal_to</class>
+    <member kind="function">
+      <type>T</type>
+      <name>memcpy</name>
+      <anchorfile>cpp/string/byte/memcpy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fwrite</name>
+      <anchorfile>cpp/io/c/fwrite</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::divides</class>
+    <class kind="class">std::collate_byname</class>
+    <member kind="function">
+      <type>T</type>
+      <name>unitbuf</name>
+      <anchorfile>cpp/io/manip/unitbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iswlower</name>
+      <anchorfile>cpp/string/wide/iswlower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mblen</name>
+      <anchorfile>cpp/string/multibyte/mblen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swscanf</name>
+      <anchorfile>cpp/io/c/fwscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstoimax</name>
+      <anchorfile>cpp/string/wide/wcstoimax</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::domain_error</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fprintf</name>
+      <anchorfile>cpp/io/c/fprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_if</name>
+      <anchorfile>cpp/algorithm/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_empty</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strtoimax</name>
+      <anchorfile>cpp/string/byte/strtoimax</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isalnum</name>
+      <anchorfile>cpp/string/byte/isalnum</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_add_explicit</name>
+      <anchorfile>cpp/atomic/atomic_fetch_add</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_nothrow_default_constructible</class>
+    <class kind="class">std::ratio_equal</class>
+    <member kind="function">
+      <type>T</type>
+      <name>push_heap</name>
+      <anchorfile>cpp/algorithm/push_heap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/algorithm/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fwprintf</name>
+      <anchorfile>cpp/io/c/fwprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostream</class>
+    <class kind="class">std::streamsize</class>
+    <member kind="function">
+      <type>T</type>
+      <name>uncaught_exception</name>
+      <anchorfile>cpp/error/uncaught_exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::shared_lock</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strtoll</name>
+      <anchorfile>cpp/string/byte/strtol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uint8_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>throw_with_nested</name>
+      <anchorfile>cpp/error/throw_with_nested</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shuffle</name>
+      <anchorfile>cpp/algorithm/random_shuffle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isprint</name>
+      <anchorfile>cpp/string/byte/isprint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_new_handler</name>
+      <anchorfile>cpp/memory/new/get_new_handler</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>call_once</name>
+      <anchorfile>cpp/thread/call_once</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>trunc</name>
+      <anchorfile>cpp/numeric/math/trunc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcscspn</name>
+      <anchorfile>cpp/string/wide/wcscspn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::enable_shared_from_this</class>
+    <class kind="class">std::ptrdiff_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>mbrtoc16</name>
+      <anchorfile>cpp/string/multibyte/mbrtoc16</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::int_fast8_t</class>
+    <class kind="class">std::aligned_union</class>
+    <member kind="function">
+      <type>T</type>
+      <name>lround</name>
+      <anchorfile>cpp/numeric/math/round</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::future</class>
+    <class kind="class">std::wcmatch</class>
+    <class kind="class">std::overflow_error</class>
+    <class kind="class">std::centi</class>
+    <member kind="function">
+      <type>T</type>
+      <name>pow</name>
+      <anchorfile>cpp/numeric/math/pow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wssub_match</class>
+    <class kind="class">std::is_nothrow_move_assignable</class>
+    <class kind="class">std::pair</class>
+    <member kind="function">
+      <type>T</type>
+      <name>tgamma</name>
+      <anchorfile>cpp/numeric/math/tgamma</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erfc</name>
+      <anchorfile>cpp/numeric/math/erfc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>llround</name>
+      <anchorfile>cpp/numeric/math/round</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>abs(float)</name>
+      <anchorfile>cpp/numeric/math/fabs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>asinh</name>
+      <anchorfile>cpp/numeric/math/asinh</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>feof</name>
+      <anchorfile>cpp/io/c/feof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wsregex_token_iterator</class>
+    <class kind="class">std::weibull_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>noskipws</name>
+      <anchorfile>cpp/io/manip/skipws</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::less</class>
+    <class kind="class">std::multiplies</class>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/algorithm/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atoi</name>
+      <anchorfile>cpp/string/byte/atoi</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_enum</class>
+    <member kind="function">
+      <type>T</type>
+      <name>not1</name>
+      <anchorfile>cpp/utility/functional/not1</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vfscanf</name>
+      <anchorfile>cpp/io/c/vfscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::unary_function</class>
+    <member kind="function">
+      <type>T</type>
+      <name>stof</name>
+      <anchorfile>cpp/string/basic_string/stof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>regex_search</name>
+      <anchorfile>cpp/regex/regex_search</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::error_code</class>
+    <class kind="class">std::yocto</class>
+    <class kind="class">std::streampos</class>
+    <class kind="class">std::istream_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rotate_copy</name>
+      <anchorfile>cpp/algorithm/rotate_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_new_handler</name>
+      <anchorfile>cpp/memory/new/set_new_handler</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>undeclare_no_pointers</name>
+      <anchorfile>cpp/memory/gc/undeclare_no_pointers</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wifstream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>async</name>
+      <anchorfile>cpp/thread/async</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>partition_point</name>
+      <anchorfile>cpp/algorithm/partition_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::moneypunct_byname</class>
+    <member kind="function">
+      <type>T</type>
+      <name>vsscanf</name>
+      <anchorfile>cpp/io/c/vfscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::terminate_handler</class>
+    <class kind="class">std::ctype_base</class>
+    <class kind="class">std::reference_wrapper</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fesetround</name>
+      <anchorfile>cpp/numeric/fenv/feround</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_is_lock_free</name>
+      <anchorfile>cpp/atomic/atomic_is_lock_free</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ranlux48_base</class>
+    <member kind="function">
+      <type>T</type>
+      <name>tanh</name>
+      <anchorfile>cpp/numeric/math/tanh</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bit_not</class>
+    <class kind="class">std::int_fast16_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>ldiv</name>
+      <anchorfile>cpp/numeric/math/div</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbase</name>
+      <anchorfile>cpp/io/manip/setbase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>remove</name>
+      <anchorfile>cpp/algorithm/remove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strtol</name>
+      <anchorfile>cpp/string/byte/strtol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strpbrk</name>
+      <anchorfile>cpp/string/byte/strpbrk</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::error_category</class>
+    <class kind="class">std::regex_traits</class>
+    <member kind="function">
+      <type>T</type>
+      <name>signbit</name>
+      <anchorfile>cpp/numeric/math/signbit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsncat</name>
+      <anchorfile>cpp/string/wide/wcsncat</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_money</name>
+      <anchorfile>cpp/io/manip/get_money</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <namespace>std::regex_constants</namespace>
+    <member kind="function">
+      <type>T</type>
+      <name>set_difference</name>
+      <anchorfile>cpp/algorithm/set_difference</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::negative_binomial_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>cref</name>
+      <anchorfile>cpp/utility/functional/ref</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_union</class>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/string/basic_string/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::mt19937</class>
+    <class kind="class">std::enable_if</class>
+    <member kind="function">
+      <type>T</type>
+      <name>to_wstring</name>
+      <anchorfile>cpp/string/basic_string/to_wstring</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::chi_squared_distribution</class>
+    <class kind="class">std::add_rvalue_reference</class>
+    <member kind="function">
+      <type>T</type>
+      <name>system</name>
+      <anchorfile>cpp/utility/program/system</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>static_pointer_cast</name>
+      <anchorfile>cpp/memory/shared_ptr/pointer_cast</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_istream</class>
+    <class kind="class">std::ostream_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstoumax</name>
+      <anchorfile>cpp/string/wide/wcstoimax</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>memmove</name>
+      <anchorfile>cpp/string/byte/memmove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getwchar</name>
+      <anchorfile>cpp/io/c/getwchar</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>scientific</name>
+      <anchorfile>cpp/io/manip/fixed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsftime</name>
+      <anchorfile>cpp/chrono/c/wcsftime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/iterator/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ceil</name>
+      <anchorfile>cpp/numeric/math/ceil</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sinh</name>
+      <anchorfile>cpp/numeric/math/sinh</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_permutation</name>
+      <anchorfile>cpp/algorithm/is_permutation</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_trivially_copy_assignable</class>
+    <member kind="function">
+      <type>T</type>
+      <name>generate_n</name>
+      <anchorfile>cpp/algorithm/generate_n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>acosh</name>
+      <anchorfile>cpp/numeric/math/acosh</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::clog</class>
+    <class kind="class">std::is_scalar</class>
+    <member kind="function">
+      <type>T</type>
+      <name>advance</name>
+      <anchorfile>cpp/iterator/advance</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uses_allocator</class>
+    <class kind="class">std::piecewise_linear_distribution</class>
+    <class kind="class">std::hash</class>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/manip/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::shuffle_order_engine</class>
+    <namespace>std::chrono</namespace>
+    <class kind="class">std::greater</class>
+    <class kind="class">std::csub_match</class>
+    <class kind="class">std::uintmax_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_xor</name>
+      <anchorfile>cpp/atomic/atomic_fetch_xor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::remove_pointer</class>
+    <class kind="class">std::numeric_limits</class>
+    <member kind="function">
+      <type>T</type>
+      <name>ws</name>
+      <anchorfile>cpp/io/manip/ws</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::add_volatile</class>
+    <class kind="class">std::once_flag</class>
+    <class kind="class">std::is_literal_type</class>
+    <class kind="class">std::money_base</class>
+    <member kind="function">
+      <type>T</type>
+      <name>signal</name>
+      <anchorfile>cpp/utility/program/signal</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>noshowbase</name>
+      <anchorfile>cpp/io/manip/showbase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::peta</class>
+    <class kind="class">std::is_placeholder</class>
+    <member kind="function">
+      <type>T</type>
+      <name>generate</name>
+      <anchorfile>cpp/algorithm/generate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ldexp</name>
+      <anchorfile>cpp/numeric/math/ldexp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::add_const</class>
+    <class kind="class">std::basic_stringbuf</class>
+    <class kind="class">std::tm</class>
+    <class kind="class">std::is_abstract</class>
+    <class kind="class">std::deque</class>
+    <member kind="function">
+      <type>T</type>
+      <name>vsnprintf</name>
+      <anchorfile>cpp/io/c/vfprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::allocator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>remove_if</name>
+      <anchorfile>cpp/algorithm/remove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::scoped_allocator_adaptor</class>
+    <class kind="class">std::ssub_match</class>
+    <member kind="function">
+      <type>T</type>
+      <name>stoull</name>
+      <anchorfile>cpp/string/basic_string/stoul</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::messages_byname</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fegetexceptflag</name>
+      <anchorfile>cpp/numeric/fenv/feexceptflag</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_if_not</name>
+      <anchorfile>cpp/algorithm/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::promise</class>
+    <member kind="function">
+      <type>T</type>
+      <name>merge</name>
+      <anchorfile>cpp/algorithm/merge</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>free</name>
+      <anchorfile>cpp/memory/c/free</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count_if</name>
+      <anchorfile>cpp/algorithm/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clock</name>
+      <anchorfile>cpp/chrono/c/clock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mktime</name>
+      <anchorfile>cpp/chrono/c/mktime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::add_pointer</class>
+    <class kind="class">std::uintptr_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>inserter</name>
+      <anchorfile>cpp/iterator/inserter</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>puts</name>
+      <anchorfile>cpp/io/c/puts</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bit_and</class>
+    <member kind="function">
+      <type>T</type>
+      <name>asin</name>
+      <anchorfile>cpp/numeric/math/asin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uniform_int_distribution</class>
+    <class kind="class">std::type_info</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iscntrl</name>
+      <anchorfile>cpp/string/byte/iscntrl</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>difftime</name>
+      <anchorfile>cpp/chrono/c/difftime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>terminate</name>
+      <anchorfile>cpp/error/terminate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>memcmp</name>
+      <anchorfile>cpp/string/byte/memcmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::fisher_f_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>uninitialized_fill</name>
+      <anchorfile>cpp/memory/uninitialized_fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::strstream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>hex</name>
+      <anchorfile>cpp/io/manip/hex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/utility/tuple/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back_inserter</name>
+      <anchorfile>cpp/iterator/back_inserter</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>upper_bound</name>
+      <anchorfile>cpp/algorithm/upper_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_get_byname</class>
+    <class kind="class">std::basic_streambuf</class>
+    <member kind="function">
+      <type>T</type>
+      <name>adjacent_find</name>
+      <anchorfile>cpp/algorithm/adjacent_find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_nothrow_constructible</class>
+    <member kind="function">
+      <type>T</type>
+      <name>use_facet</name>
+      <anchorfile>cpp/locale/use_facet</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::queue</class>
+    <class kind="class">std::is_base_of</class>
+    <class kind="class">std::intmax_t</class>
+    <class kind="class">std::ranlux24</class>
+    <member kind="function">
+      <type>T</type>
+      <name>vfwprintf</name>
+      <anchorfile>cpp/io/c/vfwprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_add</name>
+      <anchorfile>cpp/atomic/atomic_fetch_add</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::remove_cv</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fsetpos</name>
+      <anchorfile>cpp/io/c/fsetpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>malloc</name>
+      <anchorfile>cpp/memory/c/malloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>localtime</name>
+      <anchorfile>cpp/chrono/c/localtime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_trivially_destructible</class>
+    <class kind="class">std::wcin</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcscmp</name>
+      <anchorfile>cpp/string/wide/wcscmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>c32rtomb</name>
+      <anchorfile>cpp/string/multibyte/c32rtomb</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isupper</name>
+      <anchorfile>cpp/string/byte/isupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::atomic</class>
+    <class kind="class">std::basic_stringstream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstod</name>
+      <anchorfile>cpp/string/wide/wcstof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tolower</name>
+      <anchorfile>cpp/string/byte/tolower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_void</class>
+    <member kind="function">
+      <type>T</type>
+      <name>sort_heap</name>
+      <anchorfile>cpp/algorithm/sort_heap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::plus</class>
+    <member kind="function">
+      <type>T</type>
+      <name>isdigit</name>
+      <anchorfile>cpp/string/byte/isdigit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bitset</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcslen</name>
+      <anchorfile>cpp/string/wide/wcslen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wmemcmp</name>
+      <anchorfile>cpp/string/wide/wmemcmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::FILE</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move_if_noexcept</name>
+      <anchorfile>cpp/utility/move_if_noexcept</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>declval</name>
+      <anchorfile>cpp/utility/declval</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fpclassify</name>
+      <anchorfile>cpp/numeric/math/fpclassify</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iswupper</name>
+      <anchorfile>cpp/string/wide/iswupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::thread</class>
+    <class kind="class">std::future_error</class>
+    <class kind="class">std::time_base</class>
+    <class kind="class">std::alignment_of</class>
+    <class kind="class">std::time_put</class>
+    <class kind="class">std::bit_or</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rand</name>
+      <anchorfile>cpp/numeric/random/rand</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_compare_exchange_weak_explicit</name>
+      <anchorfile>cpp/atomic/atomic_compare_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::pointer_traits</class>
+    <member kind="function">
+      <type>T</type>
+      <name>partial_sort</name>
+      <anchorfile>cpp/algorithm/partial_sort</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_string</class>
+    <member kind="function">
+      <type>T</type>
+      <name>llrint</name>
+      <anchorfile>cpp/numeric/math/rint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::priority_queue</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fclose</name>
+      <anchorfile>cpp/io/c/fclose</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reverse</name>
+      <anchorfile>cpp/algorithm/reverse</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::exa</class>
+    <member kind="function">
+      <type>T</type>
+      <name>partial_sum</name>
+      <anchorfile>cpp/algorithm/partial_sum</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wostringstream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>showbase</name>
+      <anchorfile>cpp/io/manip/showbase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_default_constructible</class>
+    <class kind="class">std::cregex_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>vswscanf</name>
+      <anchorfile>cpp/io/c/vfwscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstring</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atan</name>
+      <anchorfile>cpp/numeric/math/atan</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atanh</name>
+      <anchorfile>cpp/numeric/math/atanh</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::remove_all_extents</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iter_swap</name>
+      <anchorfile>cpp/algorithm/iter_swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>scalbln</name>
+      <anchorfile>cpp/numeric/math/scalbn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istrstream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>reverse_copy</name>
+      <anchorfile>cpp/algorithm/reverse_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::unary_negate</class>
+    <class kind="class">std::unordered_multiset</class>
+    <class kind="class">std::basic_ostream</class>
+    <class kind="class">std::wsregex_iterator</class>
+    <class kind="class">std::uint_fast16_t</class>
+    <class kind="class">std::is_nothrow_assignable</class>
+    <member kind="function">
+      <type>T</type>
+      <name>forward</name>
+      <anchorfile>cpp/utility/forward</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::moneypunct</class>
+    <member kind="function">
+      <type>T</type>
+      <name>getc</name>
+      <anchorfile>cpp/io/c/fgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::type_index</class>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/algorithm/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_sub</name>
+      <anchorfile>cpp/atomic/atomic_fetch_sub</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_partitioned</name>
+      <anchorfile>cpp/algorithm/is_partitioned</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>next_permutation</name>
+      <anchorfile>cpp/algorithm/next_permutation</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isblank</name>
+      <anchorfile>cpp/string/byte/isblank</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>noshowpoint</name>
+      <anchorfile>cpp/io/manip/showpoint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atan2</name>
+      <anchorfile>cpp/numeric/math/atan2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>nanf</name>
+      <anchorfile>cpp/numeric/math/nan</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>towctrans</name>
+      <anchorfile>cpp/string/wide/towctrans</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_standard_layout</class>
+    <class kind="class">std::timed_mutex</class>
+    <member kind="function">
+      <type>T</type>
+      <name>right</name>
+      <anchorfile>cpp/io/manip/left</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fputwc</name>
+      <anchorfile>cpp/io/c/fputwc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strtoul</name>
+      <anchorfile>cpp/string/byte/strtoul</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_heap</name>
+      <anchorfile>cpp/algorithm/is_heap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bad_exception</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fflush</name>
+      <anchorfile>cpp/io/c/fflush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strtoumax</name>
+      <anchorfile>cpp/string/byte/strtoimax</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>nexttoward</name>
+      <anchorfile>cpp/numeric/math/nextafter</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::int_fast64_t</class>
+    <class kind="class">std::function</class>
+    <member kind="function">
+      <type>T</type>
+      <name>nounitbuf</name>
+      <anchorfile>cpp/io/manip/unitbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bad_cast</class>
+    <class kind="class">std::error_condition</class>
+    <class kind="class">std::filebuf</class>
+    <class kind="class">std::int_least16_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>ispunct</name>
+      <anchorfile>cpp/string/byte/ispunct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istreambuf_iterator</class>
+    <class kind="class">std::u16string</class>
+    <member kind="function">
+      <type>T</type>
+      <name>noboolalpha</name>
+      <anchorfile>cpp/io/manip/boolalpha</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>make_pair</name>
+      <anchorfile>cpp/utility/pair/make_pair</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_error_condition_enum</class>
+    <class kind="class">std::is_nothrow_destructible</class>
+    <class kind="class">std::wiostream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswctype</name>
+      <anchorfile>cpp/string/wide/iswctype</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::allocator_arg_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>srand</name>
+      <anchorfile>cpp/numeric/random/srand</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <namespace>std::rel_ops</namespace>
+    <class kind="class">std::uint_least32_t</class>
+    <class kind="class">std::collate</class>
+    <member kind="function">
+      <type>T</type>
+      <name>replace_copy</name>
+      <anchorfile>cpp/algorithm/replace_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>future_category</name>
+      <anchorfile>cpp/thread/future/future_category</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::remove_const</class>
+    <member kind="function">
+      <type>T</type>
+      <name>resetiosflags</name>
+      <anchorfile>cpp/io/manip/resetiosflags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vprintf</name>
+      <anchorfile>cpp/io/c/vfprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::u32string</class>
+    <class kind="class">std::uint_fast32_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>gmtime</name>
+      <anchorfile>cpp/chrono/c/gmtime</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_lvalue_reference</class>
+    <member kind="function">
+      <type>T</type>
+      <name>align</name>
+      <anchorfile>cpp/memory/align</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tuple_cat</name>
+      <anchorfile>cpp/utility/tuple/tuple_cat</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ends</name>
+      <anchorfile>cpp/io/manip/ends</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_terminate</name>
+      <anchorfile>cpp/error/set_terminate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lrint</name>
+      <anchorfile>cpp/numeric/math/rint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::complex</class>
+    <class kind="class">std::ofstream</class>
+    <class kind="class">std::insert_iterator</class>
+    <class kind="class">std::bad_array_length</class>
+    <member kind="function">
+      <type>T</type>
+      <name>none_of</name>
+      <anchorfile>cpp/algorithm/all_any_none_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <namespace>std::this_thread</namespace>
+    <member kind="function">
+      <type>T</type>
+      <name>wscanf</name>
+      <anchorfile>cpp/io/c/fwscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fputc</name>
+      <anchorfile>cpp/io/c/fputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>dec</name>
+      <anchorfile>cpp/io/manip/hex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strcat</name>
+      <anchorfile>cpp/string/byte/strcat</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_trivially_copyable</class>
+    <class kind="class">std::basic_istringstream</class>
+    <class kind="class">std::basic_ifstream</class>
+    <class kind="class">std::list</class>
+    <member kind="function">
+      <type>T</type>
+      <name>raise</name>
+      <anchorfile>cpp/utility/program/raise</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::minus</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsspn</name>
+      <anchorfile>cpp/string/wide/wcsspn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fabs</name>
+      <anchorfile>cpp/numeric/math/fabs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wmemcpy</name>
+      <anchorfile>cpp/string/wide/wmemcpy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy_n</name>
+      <anchorfile>cpp/algorithm/copy_n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::map</class>
+    <class kind="class">std::linear_congruential_engine</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rethrow_if_nested</name>
+      <anchorfile>cpp/error/rethrow_if_nested</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setlocale</name>
+      <anchorfile>cpp/locale/setlocale</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf16</class>
+    <member kind="function">
+      <type>T</type>
+      <name>addressof</name>
+      <anchorfile>cpp/memory/addressof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>calloc</name>
+      <anchorfile>cpp/memory/c/calloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::cmatch</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strerror</name>
+      <anchorfile>cpp/string/byte/strerror</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::defer_lock_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strcpy</name>
+      <anchorfile>cpp/string/byte/strcpy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::exception</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstoull</name>
+      <anchorfile>cpp/string/wide/wcstoul</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>c16rtomb</name>
+      <anchorfile>cpp/string/multibyte/c16rtomb</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::front_insert_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>generate_canonical</name>
+      <anchorfile>cpp/numeric/random/generate_canonical</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vfprintf</name>
+      <anchorfile>cpp/io/c/vfprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>notify_all_at_thread_exit</name>
+      <anchorfile>cpp/thread/notify_all_at_thread_exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rotate</name>
+      <anchorfile>cpp/algorithm/rotate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>current_exception</name>
+      <anchorfile>cpp/error/current_exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strtok</name>
+      <anchorfile>cpp/string/byte/strtok</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcscat</name>
+      <anchorfile>cpp/string/wide/wcscat</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strncpy</name>
+      <anchorfile>cpp/string/byte/strncpy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>towlower</name>
+      <anchorfile>cpp/string/wide/towlower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>floor</name>
+      <anchorfile>cpp/numeric/math/floor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::zetta</class>
+    <member kind="function">
+      <type>T</type>
+      <name>left</name>
+      <anchorfile>cpp/io/manip/left</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ferror</name>
+      <anchorfile>cpp/io/c/ferror</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::streambuf</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_load_explicit</name>
+      <anchorfile>cpp/atomic/atomic_load</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <namespace>std::experimental</namespace>
+    <class kind="class">std::num_put</class>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/algorithm/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>acos</name>
+      <anchorfile>cpp/numeric/math/acos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::owner_less</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcscoll</name>
+      <anchorfile>cpp/string/wide/wcscoll</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sqrt</name>
+      <anchorfile>cpp/numeric/math/sqrt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::extent</class>
+    <member kind="function">
+      <type>T</type>
+      <name>mbsinit</name>
+      <anchorfile>cpp/string/multibyte/mbsinit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bad_optional_access</class>
+    <member kind="function">
+      <type>T</type>
+      <name>qsort</name>
+      <anchorfile>cpp/algorithm/qsort</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>stoll</name>
+      <anchorfile>cpp/string/basic_string/stol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put_money</name>
+      <anchorfile>cpp/io/manip/put_money</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstoul</name>
+      <anchorfile>cpp/string/wide/wcstoul</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstol</name>
+      <anchorfile>cpp/string/wide/wcstol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atexit</name>
+      <anchorfile>cpp/utility/program/atexit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_fetch_or</name>
+      <anchorfile>cpp/atomic/atomic_fetch_or</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rewind</name>
+      <anchorfile>cpp/io/c/rewind</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsxfrm</name>
+      <anchorfile>cpp/string/wide/wcsxfrm</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::yotta</class>
+    <class kind="class">std::wcregex_token_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>round</name>
+      <anchorfile>cpp/numeric/math/round</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uint64_t</class>
+    <class kind="class">std::messages</class>
+    <member kind="function">
+      <type>T</type>
+      <name>vwprintf</name>
+      <anchorfile>cpp/io/c/vfwprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>all_of</name>
+      <anchorfile>cpp/algorithm/all_any_none_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::regex_token_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>replace</name>
+      <anchorfile>cpp/algorithm/replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::move_iterator</class>
+    <member kind="function">
+      <type>T</type>
+      <name>remquo</name>
+      <anchorfile>cpp/numeric/math/remquo</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/c/setbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::messages_base</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strncmp</name>
+      <anchorfile>cpp/string/byte/strncmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>localeconv</name>
+      <anchorfile>cpp/locale/localeconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wctrans</name>
+      <anchorfile>cpp/string/wide/wctrans</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istringstream</class>
+    <class kind="class">std::giga</class>
+    <member kind="function">
+      <type>T</type>
+      <name>any_of</name>
+      <anchorfile>cpp/algorithm/all_any_none_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::integer_sequence</class>
+    <member kind="function">
+      <type>T</type>
+      <name>equal</name>
+      <anchorfile>cpp/algorithm/equal</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/algorithm/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strxfrm</name>
+      <anchorfile>cpp/string/byte/strxfrm</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::has_virtual_destructor</class>
+    <class kind="class">std::max_align_t</class>
+    <class kind="class">std::remove_volatile</class>
+    <class kind="class">std::underlying_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswxdigit</name>
+      <anchorfile>cpp/string/wide/iswxdigit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>labs</name>
+      <anchorfile>cpp/numeric/math/abs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::hecto</class>
+    <member kind="function">
+      <type>T</type>
+      <name>regex_match</name>
+      <anchorfile>cpp/regex/regex_match</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_member_object_pointer</class>
+    <class kind="class">std::exception_ptr</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fputws</name>
+      <anchorfile>cpp/io/c/fputws</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcrtomb</name>
+      <anchorfile>cpp/string/multibyte/wcrtomb</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setprecision</name>
+      <anchorfile>cpp/io/manip/setprecision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setvbuf</name>
+      <anchorfile>cpp/io/c/setvbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::nested_exception</class>
+    <class kind="class">std::random_access_iterator_tag</class>
+    <member kind="function">
+      <type>T</type>
+      <name>regex_replace</name>
+      <anchorfile>cpp/regex/regex_replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ctype</class>
+    <member kind="function">
+      <type>T</type>
+      <name>freopen</name>
+      <anchorfile>cpp/io/c/freopen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>logb</name>
+      <anchorfile>cpp/numeric/math/logb</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wctob</name>
+      <anchorfile>cpp/string/multibyte/wctob</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::knuth_b</class>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_load</name>
+      <anchorfile>cpp/atomic/atomic_load</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>search_n</name>
+      <anchorfile>cpp/algorithm/search_n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>toupper</name>
+      <anchorfile>cpp/string/byte/toupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::auto_ptr</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move_backward</name>
+      <anchorfile>cpp/algorithm/move_backward</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_sorted</name>
+      <anchorfile>cpp/algorithm/is_sorted</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::minstd_rand0</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strtoull</name>
+      <anchorfile>cpp/string/byte/strtoul</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::sregex_token_iterator</class>
+    <class kind="class">std::logical_not</class>
+    <class kind="class">std::fpos_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswblank</name>
+      <anchorfile>cpp/string/wide/iswblank</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istream</class>
+    <class kind="class">std::seed_seq</class>
+    <class kind="class">std::default_delete</class>
+    <class kind="class">std::femto</class>
+    <class kind="class">std::clock_t</class>
+    <class kind="class">std::true_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get_pointer_safety</name>
+      <anchorfile>cpp/memory/gc/get_pointer_safety</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::mbstate_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get_unexpected</name>
+      <anchorfile>cpp/error/get_unexpected</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sscanf</name>
+      <anchorfile>cpp/io/c/fscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostrstream</class>
+    <class kind="class">std::gamma_distribution</class>
+    <class kind="class">std::bad_weak_ptr</class>
+    <class kind="class">std::output_iterator_tag</class>
+    <class kind="class">std::micro</class>
+    <class kind="class">std::is_trivial</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fesetenv</name>
+      <anchorfile>cpp/numeric/fenv/feenv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_store_explicit</name>
+      <anchorfile>cpp/atomic/atomic_store</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strtold</name>
+      <anchorfile>cpp/string/byte/strtof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fread</name>
+      <anchorfile>cpp/io/c/fread</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::packaged_task</class>
+    <class kind="class">std::unordered_set</class>
+    <class kind="class">std::is_volatile</class>
+    <member kind="function">
+      <type>T</type>
+      <name>memchr</name>
+      <anchorfile>cpp/string/byte/memchr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>btowc</name>
+      <anchorfile>cpp/string/multibyte/btowc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wfstream</class>
+    <member kind="function">
+      <type>T</type>
+      <name>replace_if</name>
+      <anchorfile>cpp/algorithm/replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::multimap</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strcoll</name>
+      <anchorfile>cpp/string/byte/strcoll</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vsprintf</name>
+      <anchorfile>cpp/io/c/vfprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mismatch</name>
+      <anchorfile>cpp/algorithm/mismatch</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getchar</name>
+      <anchorfile>cpp/io/c/getchar</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::atomic_flag</class>
+    <member kind="function">
+      <type>T</type>
+      <name>islower</name>
+      <anchorfile>cpp/string/byte/islower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tmpnam</name>
+      <anchorfile>cpp/io/c/tmpnam</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::numpunct_byname</class>
+    <member kind="function">
+      <type>T</type>
+      <name>nanl</name>
+      <anchorfile>cpp/numeric/math/nan</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::binomial_distribution</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fopen</name>
+      <anchorfile>cpp/io/c/fopen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_iostream</class>
+    <class kind="class">std::wofstream</class>
+    <class kind="class">std::fpos</class>
+    <class kind="class">std::underflow_error</class>
+    <member kind="function">
+      <type>T</type>
+      <name>for_each</name>
+      <anchorfile>cpp/algorithm/for_each</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fegetround</name>
+      <anchorfile>cpp/numeric/fenv/feround</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ungetc</name>
+      <anchorfile>cpp/io/c/ungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::cauchy_distribution</class>
+    <class kind="class">std::is_trivially_copy_constructible</class>
+    <class kind="class">std::conditional</class>
+    <class kind="class">std::is_pod</class>
+    <member kind="function">
+      <type>T</type>
+      <name>internal</name>
+      <anchorfile>cpp/io/manip/left</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vfwscanf</name>
+      <anchorfile>cpp/io/c/vfwscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::int_least8_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fgetc</name>
+      <anchorfile>cpp/io/c/fgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::streamoff</class>
+    <class kind="class">std::is_move_assignable</class>
+    <class kind="class">std::int_least32_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstof</name>
+      <anchorfile>cpp/string/wide/wcstof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstringstream</class>
+    <class kind="class">std::subtract_with_carry_engine</class>
+    <class kind="class">std::regex_error</class>
+    <member kind="function">
+      <type>T</type>
+      <name>bind</name>
+      <anchorfile>cpp/utility/functional/bind</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>skipws</name>
+      <anchorfile>cpp/io/manip/skipws</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_constructible</class>
+    <class kind="class">std::piecewise_construct_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>iswprint</name>
+      <anchorfile>cpp/string/wide/iswprint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcstombs</name>
+      <anchorfile>cpp/string/multibyte/wcstombs</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>inplace_merge</name>
+      <anchorfile>cpp/algorithm/inplace_merge</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copysign</name>
+      <anchorfile>cpp/numeric/math/copysign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putwchar</name>
+      <anchorfile>cpp/io/c/putwchar</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::mutex</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsstr</name>
+      <anchorfile>cpp/string/wide/wcsstr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fegetenv</name>
+      <anchorfile>cpp/numeric/fenv/feenv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>longjmp</name>
+      <anchorfile>cpp/utility/program/longjmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iswcntrl</name>
+      <anchorfile>cpp/string/wide/iswcntrl</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::system_error</class>
+    <member kind="function">
+      <type>T</type>
+      <name>declare_no_pointers</name>
+      <anchorfile>cpp/memory/gc/declare_no_pointers</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isnormal</name>
+      <anchorfile>cpp/numeric/math/isnormal</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap_ranges</name>
+      <anchorfile>cpp/algorithm/swap_ranges</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistringstream</class>
+    <class kind="class">std::is_floating_point</class>
+    <member kind="function">
+      <type>T</type>
+      <name>minmax</name>
+      <anchorfile>cpp/algorithm/minmax</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>defaultfloat</name>
+      <anchorfile>cpp/io/manip/fixed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rename</name>
+      <anchorfile>cpp/io/c/rename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snprintf</name>
+      <anchorfile>cpp/io/c/fprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ratio_not_equal</class>
+    <class kind="class">std::ratio_multiply</class>
+    <class kind="class">std::result_of</class>
+    <class kind="class">std::is_fundamental</class>
+    <member kind="function">
+      <type>T</type>
+      <name>stoul</name>
+      <anchorfile>cpp/string/basic_string/stoul</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ifstream</class>
+    <class kind="class">std::u32streampos</class>
+    <member kind="function">
+      <type>T</type>
+      <name>fgetpos</name>
+      <anchorfile>cpp/io/c/fgetpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::length_error</class>
+    <member kind="function">
+      <type>T</type>
+      <name>partition_copy</name>
+      <anchorfile>cpp/algorithm/partition_copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vscanf</name>
+      <anchorfile>cpp/io/c/vfscanf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front_inserter</name>
+      <anchorfile>cpp/iterator/front_inserter</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::sub_match</class>
+    <class kind="class">std::common_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get_terminate</name>
+      <anchorfile>cpp/error/get_terminate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cosh</name>
+      <anchorfile>cpp/numeric/math/cosh</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::shared_timed_mutex</class>
+    <class kind="class">std::array</class>
+    <class kind="class">std::random_device</class>
+    <class kind="class">std::default_random_engine</class>
+    <class kind="class">std::raw_storage_iterator</class>
+    <class kind="class">std::is_convertible</class>
+    <member kind="function">
+      <type>T</type>
+      <name>prev</name>
+      <anchorfile>cpp/iterator/prev</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::uint16_t</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strchr</name>
+      <anchorfile>cpp/string/byte/strchr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::is_array</class>
+    <member kind="function">
+      <type>T</type>
+      <name>strstr</name>
+      <anchorfile>cpp/string/byte/strstr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::mega</class>
+    <member kind="function">
+      <type>T</type>
+      <name>printf</name>
+      <anchorfile>cpp/io/c/fprintf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::numpunct</class>
+    <class kind="class">std::money_put</class>
+    <class kind="class">std::new_handler</class>
+    <class kind="class">std::is_member_function_pointer</class>
+    <member kind="function">
+      <type>T</type>
+      <name>setfill</name>
+      <anchorfile>cpp/io/manip/setfill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>inner_product</name>
+      <anchorfile>cpp/algorithm/inner_product</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_function</name>
+    <filename>cpp/types/is_function</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::input_iterator_tag</name>
+    <filename>cpp/iterator/iterator_tags</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::logical_and</name>
+    <filename>cpp/utility/functional/logical_and</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/logical_and</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_integral</name>
+    <filename>cpp/types/is_integral</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_get</name>
+    <filename>cpp/locale/money_get</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get</name>
+      <anchorfile>cpp/locale/money_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::money_get::char_type</class>
+    <class kind="class">std::money_get::pattern</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/locale/money_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~money_get</name>
+      <anchorfile>cpp/locale/money_get/~money_get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::money_get::string_type</class>
+    <class kind="class">std::money_get::iter_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>money_get</name>
+      <anchorfile>cpp/locale/money_get/money_get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::money_get::char_type</name>
+    <filename>cpp/locale/money_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_get::pattern</name>
+    <filename>cpp/locale/money_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_get::string_type</name>
+    <filename>cpp/locale/money_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_get::iter_type</name>
+    <filename>cpp/locale/money_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ofstream</name>
+    <filename>cpp/io/basic_ofstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_ofstream</name>
+      <anchorfile>cpp/io/basic_ofstream/basic_ofstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ofstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_ofstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_ofstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ofstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_ofstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ofstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ofstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ofstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ofstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ofstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_subtract</name>
+    <filename>cpp/numeric/ratio/ratio_subtract</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::size_t</name>
+    <filename>cpp/types/size_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ctype_byname</name>
+    <filename>cpp/locale/ctype_byname</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~ctype_byname</name>
+      <anchorfile>cpp/locale/ctype_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ctype_byname</name>
+      <anchorfile>cpp/locale/ctype_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_toupper</name>
+      <anchorfile>cpp/locale/ctype/toupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>toupper</name>
+      <anchorfile>cpp/locale/ctype/toupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_scan_is</name>
+      <anchorfile>cpp/locale/ctype/scan_is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_tolower</name>
+      <anchorfile>cpp/locale/ctype/tolower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_narrow</name>
+      <anchorfile>cpp/locale/ctype/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/locale/ctype/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is</name>
+      <anchorfile>cpp/locale/ctype/is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>scan_is</name>
+      <anchorfile>cpp/locale/ctype/scan_is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tolower</name>
+      <anchorfile>cpp/locale/ctype/tolower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_is</name>
+      <anchorfile>cpp/locale/ctype/is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/locale/ctype/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ctype_byname::mask</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_widen</name>
+      <anchorfile>cpp/locale/ctype/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ctype_byname::mask</name>
+    <filename>cpp/locale/ctype_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wcout</name>
+    <filename>cpp/io/basic_ostream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::fstream</name>
+    <filename>cpp/io/basic_fstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_fstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fstream</name>
+      <anchorfile>cpp/io/basic_fstream/basic_fstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::fstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::fstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_fstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::fstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_fstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_fstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::fstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::fstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::fstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::valarray</name>
+    <filename>cpp/numeric/valarray</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_greater_equal</name>
+    <filename>cpp/numeric/ratio/ratio_greater_equal</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::remove_extent</name>
+    <filename>cpp/types/remove_extent</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_greater</name>
+    <filename>cpp/numeric/ratio/ratio_greater</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::intptr_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::regex_iterator</name>
+    <filename>cpp/regex/regex_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>regex_iterator</name>
+      <anchorfile>cpp/regex/regex_iterator/regex_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::lock_guard</name>
+    <filename>cpp/thread/lock_guard</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~lock_guard</name>
+      <anchorfile>cpp/thread/lock_guard/~lock_guard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock_guard</name>
+      <anchorfile>cpp/thread/lock_guard/lock_guard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wbuffer_convert</name>
+    <filename>cpp/locale/wbuffer_convert</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>state</name>
+      <anchorfile>cpp/locale/wbuffer_convert/state</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wbuffer_convert</name>
+      <anchorfile>cpp/locale/wbuffer_convert/wbuffer_convert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/locale/wbuffer_convert/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wbuffer_convert</name>
+      <anchorfile>cpp/locale/wbuffer_convert/~wbuffer_convert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::modulus</name>
+    <filename>cpp/utility/functional/modulus</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/modulus</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_divide</name>
+    <filename>cpp/numeric/ratio/ratio_divide</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ostreambuf_iterator</name>
+    <filename>cpp/iterator/ostreambuf_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::dynarray</name>
+    <filename>cpp/container/dynarray</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/dynarray/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/dynarray/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/dynarray/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/container/dynarray/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/container/dynarray/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/container/dynarray/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/dynarray/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/container/dynarray/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/dynarray/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/dynarray/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/dynarray/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~dynarray</name>
+      <anchorfile>cpp/container/dynarray/~dynarray</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/dynarray/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/dynarray/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/container/dynarray/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>dynarray</name>
+      <anchorfile>cpp/container/dynarray/dynarray</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/container/dynarray/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/dynarray/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/dynarray/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_move_constructible</name>
+    <filename>cpp/types/is_move_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::vector</name>
+    <filename>cpp/container/vector</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/container/vector/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/vector/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/vector/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/container/vector/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/vector/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/container/vector/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shrink_to_fit</name>
+      <anchorfile>cpp/container/vector/shrink_to_fit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/container/vector/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/vector/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/container/vector/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_back</name>
+      <anchorfile>cpp/container/vector/emplace_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/vector/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/vector/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/container/vector/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~vector</name>
+      <anchorfile>cpp/container/vector/~vector</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/vector/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/vector/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/container/vector/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/vector/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>vector</name>
+      <anchorfile>cpp/container/vector/vector</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/container/vector/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>capacity</name>
+      <anchorfile>cpp/container/vector/capacity</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/vector/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/vector/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/vector/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/vector/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/vector/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/vector/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/vector/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/container/vector/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/vector/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/container/vector/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/vector/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::match_results</name>
+    <filename>cpp/regex/match_results</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>format</name>
+      <anchorfile>cpp/regex/match_results/format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~match_results</name>
+      <anchorfile>cpp/regex/match_results/~match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/regex/match_results/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/match_results/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>position</name>
+      <anchorfile>cpp/regex/match_results/position</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>prefix</name>
+      <anchorfile>cpp/regex/match_results/prefix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/match_results/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/regex/match_results/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>suffix</name>
+      <anchorfile>cpp/regex/match_results/suffix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/regex/match_results/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>match_results</name>
+      <anchorfile>cpp/regex/match_results/match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ready</name>
+      <anchorfile>cpp/regex/match_results/ready</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/regex/match_results/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/match_results/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/regex/match_results/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::back_insert_iterator</name>
+    <filename>cpp/iterator/back_insert_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::iterator</name>
+    <filename>cpp/iterator/iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int8_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::student_t_distribution</name>
+    <filename>cpp/numeric/random/student_t_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>n</name>
+      <anchorfile>cpp/numeric/random/student_t_distribution/n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/student_t_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/student_t_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/student_t_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>student_t_distribution</name>
+      <anchorfile>cpp/numeric/random/student_t_distribution/student_t_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/student_t_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/student_t_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::mt19937_64</name>
+    <filename>cpp/numeric/random/mersenne_twister_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mt19937_64</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::runtime_error</name>
+    <filename>cpp/error/runtime_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>runtime_error</name>
+      <anchorfile>cpp/error/runtime_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ranlux24_base</name>
+    <filename>cpp/numeric/random/subtract_with_carry_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ranlux24_base</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::allocator_traits</name>
+    <filename>cpp/memory/allocator_traits</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>destroy</name>
+      <anchorfile>cpp/memory/allocator_traits/destroy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>select_on_container_copy_construction</name>
+      <anchorfile>cpp/memory/allocator_traits/select_on_container_copy_construction</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/memory/allocator_traits/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>allocate</name>
+      <anchorfile>cpp/memory/allocator_traits/allocate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>deallocate</name>
+      <anchorfile>cpp/memory/allocator_traits/deallocate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>construct</name>
+      <anchorfile>cpp/memory/allocator_traits/construct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt</name>
+    <filename>cpp/locale/codecvt</filename>
+    <class kind="class">std::codecvt::extern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt::state_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>codecvt</name>
+      <anchorfile>cpp/locale/codecvt/codecvt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt::intern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~codecvt</name>
+      <anchorfile>cpp/locale/codecvt/~codecvt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt::extern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt::state_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt::intern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_less_equal</name>
+    <filename>cpp/numeric/ratio/ratio_less_equal</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::condition_variable_any</name>
+    <filename>cpp/thread/condition_variable_any</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>condition_variable_any</name>
+      <anchorfile>cpp/thread/condition_variable_any/condition_variable_any</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>notify_one</name>
+      <anchorfile>cpp/thread/condition_variable_any/notify_one</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_for</name>
+      <anchorfile>cpp/thread/condition_variable_any/wait_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>native_handle</name>
+      <anchorfile>cpp/thread/condition_variable_any/native_handle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>notify_all</name>
+      <anchorfile>cpp/thread/condition_variable_any/notify_all</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~condition_variable_any</name>
+      <anchorfile>cpp/thread/condition_variable_any/~condition_variable_any</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_until</name>
+      <anchorfile>cpp/thread/condition_variable_any/wait_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait</name>
+      <anchorfile>cpp/thread/condition_variable_any/wait</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::deca</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::extreme_value_distribution</name>
+    <filename>cpp/numeric/random/extreme_value_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>b</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>a</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>extreme_value_distribution</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/extreme_value_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/extreme_value_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::cout</name>
+    <filename>cpp/io/basic_ostream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::decay</name>
+    <filename>cpp/types/decay</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_move_assignable</name>
+    <filename>cpp/types/is_move_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::adopt_lock_t</name>
+    <filename>cpp/thread/lock_tag_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wcerr</name>
+    <filename>cpp/io/basic_ostream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::lognormal_distribution</name>
+    <filename>cpp/numeric/random/lognormal_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lognormal_distribution</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/lognormal_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>m</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>s</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/lognormal_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wclog</name>
+    <filename>cpp/io/basic_ostream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::char_traits</name>
+    <filename>cpp/string/char_traits</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/string/char_traits/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>not_eof</name>
+      <anchorfile>cpp/string/char_traits/not_eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_int_type</name>
+      <anchorfile>cpp/string/char_traits/to_int_type</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_char_type</name>
+      <anchorfile>cpp/string/char_traits/to_char_type</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eq</name>
+      <anchorfile>cpp/string/char_traits/cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy</name>
+      <anchorfile>cpp/string/char_traits/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/string/char_traits/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lt</name>
+      <anchorfile>cpp/string/char_traits/cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/string/char_traits/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/string/char_traits/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/string/char_traits/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/string/char_traits/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eq_int_type</name>
+      <anchorfile>cpp/string/char_traits/eq_int_type</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::remove_reference</name>
+    <filename>cpp/types/remove_reference</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::num_get</name>
+    <filename>cpp/locale/num_get</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get</name>
+      <anchorfile>cpp/locale/num_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::num_get::char_type</class>
+    <class kind="class">std::num_get::iter_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>num_get</name>
+      <anchorfile>cpp/locale/num_get/num_get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~num_get</name>
+      <anchorfile>cpp/locale/num_get/~num_get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/locale/num_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::num_get::char_type</name>
+    <filename>cpp/locale/num_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::num_get::iter_type</name>
+    <filename>cpp/locale/num_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_pointer</name>
+    <filename>cpp/types/is_pointer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::multiset</name>
+    <filename>cpp/container/multiset</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/multiset/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/multiset/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/multiset/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/multiset/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/multiset/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/multiset/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_comp</name>
+      <anchorfile>cpp/container/multiset/key_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/multiset/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/multiset/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/multiset/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/multiset/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>multiset</name>
+      <anchorfile>cpp/container/multiset/multiset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>upper_bound</name>
+      <anchorfile>cpp/container/multiset/upper_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/multiset/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/multiset/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/multiset/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/multiset/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~multiset</name>
+      <anchorfile>cpp/container/multiset/~multiset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>value_comp</name>
+      <anchorfile>cpp/container/multiset/value_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/multiset/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lower_bound</name>
+      <anchorfile>cpp/container/multiset/lower_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/multiset/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/multiset/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/multiset/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/multiset/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/multiset/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/multiset/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/multiset/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::weak_ptr</name>
+    <filename>cpp/memory/weak_ptr</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/memory/weak_ptr/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/memory/weak_ptr/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>weak_ptr</name>
+      <anchorfile>cpp/memory/weak_ptr/weak_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>owner_before</name>
+      <anchorfile>cpp/memory/weak_ptr/owner_before</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~weak_ptr</name>
+      <anchorfile>cpp/memory/weak_ptr/~weak_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>use_count</name>
+      <anchorfile>cpp/memory/weak_ptr/use_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>expired</name>
+      <anchorfile>cpp/memory/weak_ptr/expired</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/memory/weak_ptr/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/memory/weak_ptr/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bidirectional_iterator_tag</name>
+    <filename>cpp/iterator/iterator_tags</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wstring_convert</name>
+    <filename>cpp/locale/wstring_convert</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>converted</name>
+      <anchorfile>cpp/locale/wstring_convert/converted</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_bytes</name>
+      <anchorfile>cpp/locale/wstring_convert/to_bytes</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wstring_convert</name>
+      <anchorfile>cpp/locale/wstring_convert/~wstring_convert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>state</name>
+      <anchorfile>cpp/locale/wstring_convert/state</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wstring_convert</name>
+      <anchorfile>cpp/locale/wstring_convert/wstring_convert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>from_bytes</name>
+      <anchorfile>cpp/locale/wstring_convert/from_bytes</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::greater_equal</name>
+    <filename>cpp/utility/functional/greater_equal</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/greater_equal</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_constructible</name>
+    <filename>cpp/types/is_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::string</name>
+    <filename>cpp/string/basic_string</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/string/basic_string/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shrink_to_fit</name>
+      <anchorfile>cpp/string/basic_string/shrink_to_fit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rfind</name>
+      <anchorfile>cpp/string/basic_string/rfind</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/string/basic_string/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>append</name>
+      <anchorfile>cpp/string/basic_string/append</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/string/basic_string/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/string/basic_string/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/string/basic_string/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/string/basic_string/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/string/basic_string/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy</name>
+      <anchorfile>cpp/string/basic_string/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/string/basic_string/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>replace</name>
+      <anchorfile>cpp/string/basic_string/replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/string/basic_string/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>substr</name>
+      <anchorfile>cpp/string/basic_string/substr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/string/basic_string/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/string/basic_string/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/string/basic_string/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/string/basic_string/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>capacity</name>
+      <anchorfile>cpp/string/basic_string/capacity</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>c_str</name>
+      <anchorfile>cpp/string/basic_string/c_str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/string/basic_string/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>string</name>
+      <anchorfile>cpp/string/basic_string/basic_string</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/string/basic_string/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/string/basic_string/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/string/basic_string/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/string/basic_string/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/string/basic_string/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/string/basic_string/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::discrete_distribution</name>
+    <filename>cpp/numeric/random/discrete_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>probabilities</name>
+      <anchorfile>cpp/numeric/random/discrete_distribution/probabilities</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/discrete_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/discrete_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>discrete_distribution</name>
+      <anchorfile>cpp/numeric/random/discrete_distribution/discrete_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/discrete_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/discrete_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/discrete_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wostream</name>
+    <filename>cpp/io/basic_ostream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wostream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wostream</name>
+      <anchorfile>cpp/io/basic_ostream/~basic_ostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wostream</name>
+      <anchorfile>cpp/io/basic_ostream/basic_ostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wostream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wostream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wostream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wostream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wostream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_polymorphic</name>
+    <filename>cpp/types/is_polymorphic</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::reverse_iterator</name>
+    <filename>cpp/iterator/reverse_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_array_new_length</name>
+    <filename>cpp/memory/new/bad_array_new_length</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_array_new_length</name>
+      <anchorfile>cpp/memory/new/bad_array_new_length/bad_array_new_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/memory/new/bad_alloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::condition_variable</name>
+    <filename>cpp/thread/condition_variable</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>wait</name>
+      <anchorfile>cpp/thread/condition_variable/wait</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>notify_one</name>
+      <anchorfile>cpp/thread/condition_variable/notify_one</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_for</name>
+      <anchorfile>cpp/thread/condition_variable/wait_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>notify_all</name>
+      <anchorfile>cpp/thread/condition_variable/notify_all</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>native_handle</name>
+      <anchorfile>cpp/thread/condition_variable/native_handle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_until</name>
+      <anchorfile>cpp/thread/condition_variable/wait_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>condition_variable</name>
+      <anchorfile>cpp/thread/condition_variable/condition_variable</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~condition_variable</name>
+      <anchorfile>cpp/thread/condition_variable/~condition_variable</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ranlux48</name>
+    <filename>cpp/numeric/random/discard_block_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ranlux48</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/discard_block_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>base</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::unexpected_handler</name>
+    <filename>cpp/error/unexpected_handler</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::piecewise_constant_distribution</name>
+    <filename>cpp/numeric/random/piecewise_constant_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>densities</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>intervals</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>piecewise_constant_distribution</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/piecewise_constant_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/piecewise_constant_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_base</name>
+    <filename>cpp/locale/codecvt_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::set</name>
+    <filename>cpp/container/set</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/set/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/set/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/set/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~set</name>
+      <anchorfile>cpp/container/set/~set</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/set/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/set/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/set/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_comp</name>
+      <anchorfile>cpp/container/set/key_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/set/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/set/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/set/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/set/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>upper_bound</name>
+      <anchorfile>cpp/container/set/upper_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/set/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/set/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/set/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set</name>
+      <anchorfile>cpp/container/set/set</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/set/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>value_comp</name>
+      <anchorfile>cpp/container/set/value_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/set/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lower_bound</name>
+      <anchorfile>cpp/container/set/lower_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/set/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/set/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/set/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/set/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/set/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/set/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/set/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::forward_iterator_tag</name>
+    <filename>cpp/iterator/iterator_tags</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_byname</name>
+    <filename>cpp/locale/codecvt_byname</filename>
+    <class kind="class">std::codecvt_byname::extern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_byname::state_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>codecvt_byname</name>
+      <anchorfile>cpp/locale/codecvt_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_byname::intern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~codecvt_byname</name>
+      <anchorfile>cpp/locale/codecvt_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_byname::extern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_byname::state_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_byname::intern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::pointer_safety</name>
+    <filename>cpp/memory/gc/pointer_safety</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_least64_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::placeholders</name>
+    <filename>cpp/utility/functional/placeholders</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::nothrow_t</name>
+    <filename>cpp/memory/new/nothrow_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_copy_assignable</name>
+    <filename>cpp/types/is_copy_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_same</name>
+    <filename>cpp/types/is_same</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::unique_lock</name>
+    <filename>cpp/thread/unique_lock</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>mutex</name>
+      <anchorfile>cpp/thread/unique_lock/mutex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/thread/unique_lock/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>owns_lock</name>
+      <anchorfile>cpp/thread/unique_lock/owns_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_for</name>
+      <anchorfile>cpp/thread/unique_lock/try_lock_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>release</name>
+      <anchorfile>cpp/thread/unique_lock/release</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/unique_lock/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/thread/unique_lock/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~unique_lock</name>
+      <anchorfile>cpp/thread/unique_lock/~unique_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock</name>
+      <anchorfile>cpp/thread/unique_lock/unlock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/thread/unique_lock/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_until</name>
+      <anchorfile>cpp/thread/unique_lock/try_lock_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/unique_lock/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unique_lock</name>
+      <anchorfile>cpp/thread/unique_lock/unique_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostringstream</name>
+    <filename>cpp/io/basic_ostringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_ostringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ostringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ostringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ostringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_ostringstream</name>
+      <anchorfile>cpp/io/basic_ostringstream/basic_ostringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ostringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostringstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_error_code_enum</name>
+    <filename>cpp/error/error_code/is_error_code_enum</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_put_byname</name>
+    <filename>cpp/locale/time_put_byname</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>time_put_byname</name>
+      <anchorfile>cpp/locale/time_put_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_put_byname::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_put</name>
+      <anchorfile>cpp/locale/time_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/locale/time_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~time_put_byname</name>
+      <anchorfile>cpp/locale/time_put_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_put_byname::iter_type</class>
+  </compound>
+  <compound kind="class">
+    <name>std::time_put_byname::char_type</name>
+    <filename>cpp/locale/time_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_put_byname::iter_type</name>
+    <filename>cpp/locale/time_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_get</name>
+    <filename>cpp/locale/time_get</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_date_order</name>
+      <anchorfile>cpp/locale/time_get/date_order</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get</name>
+      <anchorfile>cpp/locale/time_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_monthname</name>
+      <anchorfile>cpp/locale/time_get/get_monthname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_weekday</name>
+      <anchorfile>cpp/locale/time_get/get_weekday</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_time</name>
+      <anchorfile>cpp/locale/time_get/get_time</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~time_get</name>
+      <anchorfile>cpp/locale/time_get/~time_get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_year</name>
+      <anchorfile>cpp/locale/time_get/get_year</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_get::iter_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get_monthname</name>
+      <anchorfile>cpp/locale/time_get/get_monthname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_time</name>
+      <anchorfile>cpp/locale/time_get/get_time</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>time_get</name>
+      <anchorfile>cpp/locale/time_get/time_get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_date</name>
+      <anchorfile>cpp/locale/time_get/get_date</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_date</name>
+      <anchorfile>cpp/locale/time_get/get_date</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_get::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>date_order</name>
+      <anchorfile>cpp/locale/time_get/date_order</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_year</name>
+      <anchorfile>cpp/locale/time_get/get_year</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/locale/time_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_weekday</name>
+      <anchorfile>cpp/locale/time_get/get_weekday</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::time_get::iter_type</name>
+    <filename>cpp/locale/time_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_get::char_type</name>
+    <filename>cpp/locale/time_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::regex</name>
+    <filename>cpp/regex/basic_regex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/basic_regex/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/basic_regex/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/regex/basic_regex/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/regex/basic_regex/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>regex</name>
+      <anchorfile>cpp/regex/basic_regex/basic_regex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mark_count</name>
+      <anchorfile>cpp/regex/basic_regex/mark_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/regex/basic_regex/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/regex/basic_regex/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~regex</name>
+      <anchorfile>cpp/regex/basic_regex/~basic_regex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::cin</name>
+    <filename>cpp/io/basic_istream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::unordered_map</name>
+    <filename>cpp/container/unordered_map</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>max_bucket_count</name>
+      <anchorfile>cpp/container/unordered_map/max_bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/unordered_map/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/unordered_map/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/unordered_map/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_count</name>
+      <anchorfile>cpp/container/unordered_map/bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_load_factor</name>
+      <anchorfile>cpp/container/unordered_map/max_load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/unordered_map/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/unordered_map/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end(int)</name>
+      <anchorfile>cpp/container/unordered_map/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>load_factor</name>
+      <anchorfile>cpp/container/unordered_map/load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/unordered_map/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_eq</name>
+      <anchorfile>cpp/container/unordered_map/key_eq</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~unordered_map</name>
+      <anchorfile>cpp/container/unordered_map/~unordered_map</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hash_function</name>
+      <anchorfile>cpp/container/unordered_map/hash_function</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/unordered_map/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/container/unordered_map/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin(int)</name>
+      <anchorfile>cpp/container/unordered_map/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/unordered_map/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin(int)</name>
+      <anchorfile>cpp/container/unordered_map/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unordered_map</name>
+      <anchorfile>cpp/container/unordered_map/unordered_map</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/unordered_map/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/unordered_map/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend(int)</name>
+      <anchorfile>cpp/container/unordered_map/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/container/unordered_map/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rehash</name>
+      <anchorfile>cpp/container/unordered_map/rehash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket</name>
+      <anchorfile>cpp/container/unordered_map/bucket</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/unordered_map/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/unordered_map/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/unordered_map/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/unordered_map/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/unordered_map/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/unordered_map/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/unordered_map/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/container/unordered_map/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/unordered_map/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_size</name>
+      <anchorfile>cpp/container/unordered_map/bucket_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::initializer_list</name>
+    <filename>cpp/utility/initializer_list</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/utility/initializer_list/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/utility/initializer_list/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>initializer_list</name>
+      <anchorfile>cpp/utility/initializer_list/initializer_list</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/utility/initializer_list/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_const</name>
+    <filename>cpp/types/is_const</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_regex</name>
+    <filename>cpp/regex/basic_regex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_regex</name>
+      <anchorfile>cpp/regex/basic_regex/basic_regex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/basic_regex/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/basic_regex/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/regex/basic_regex/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~basic_regex</name>
+      <anchorfile>cpp/regex/basic_regex/~basic_regex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/regex/basic_regex/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mark_count</name>
+      <anchorfile>cpp/regex/basic_regex/mark_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/regex/basic_regex/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/regex/basic_regex/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::poisson_distribution</name>
+    <filename>cpp/numeric/random/poisson_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>poisson_distribution</name>
+      <anchorfile>cpp/numeric/random/poisson_distribution/poisson_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mean</name>
+      <anchorfile>cpp/numeric/random/poisson_distribution/mean</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/poisson_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/poisson_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/poisson_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/poisson_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_typeid</name>
+    <filename>cpp/types/bad_typeid</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_typeid</name>
+      <anchorfile>cpp/types/bad_typeid/bad_typeid</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::less_equal</name>
+    <filename>cpp/utility/functional/less_equal</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/less_equal</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::sig_atomic_t</name>
+    <filename>cpp/utility/program/sig_atomic_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::make_unsigned</name>
+    <filename>cpp/types/make_unsigned</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_filebuf</name>
+    <filename>cpp/io/basic_filebuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_filebuf</name>
+      <anchorfile>cpp/io/basic_filebuf/basic_filebuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_filebuf/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~basic_filebuf</name>
+      <anchorfile>cpp/io/basic_filebuf/~basic_filebuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_filebuf/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_filebuf/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_filebuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::logical_or</name>
+    <filename>cpp/utility/functional/logical_or</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/logical_or</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wstringbuf</name>
+    <filename>cpp/io/basic_stringbuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_stringbuf/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_stringbuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wstringbuf</name>
+      <anchorfile>cpp/io/basic_stringbuf/basic_stringbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::kilo</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::bernoulli_distribution</name>
+    <filename>cpp/numeric/random/bernoulli_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bernoulli_distribution</name>
+      <anchorfile>cpp/numeric/random/bernoulli_distribution/bernoulli_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>p</name>
+      <anchorfile>cpp/numeric/random/bernoulli_distribution/p</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/bernoulli_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/bernoulli_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/bernoulli_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/bernoulli_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::int16_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ios</name>
+    <filename>cpp/io/basic_ios</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/ios_base/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ios::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_ios</name>
+      <anchorfile>cpp/io/basic_ios/basic_ios</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~basic_ios</name>
+      <anchorfile>cpp/io/basic_ios/~basic_ios</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ios::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ios::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ios::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int32_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_rvalue_reference</name>
+    <filename>cpp/types/is_rvalue_reference</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::integral_constant</name>
+    <filename>cpp/types/integral_constant</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wsmatch</name>
+    <filename>cpp/regex/match_results</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>format</name>
+      <anchorfile>cpp/regex/match_results/format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wsmatch</name>
+      <anchorfile>cpp/regex/match_results/match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/regex/match_results/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/match_results/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>position</name>
+      <anchorfile>cpp/regex/match_results/position</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>prefix</name>
+      <anchorfile>cpp/regex/match_results/prefix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/match_results/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wsmatch</name>
+      <anchorfile>cpp/regex/match_results/~match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/regex/match_results/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>suffix</name>
+      <anchorfile>cpp/regex/match_results/suffix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/regex/match_results/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/regex/match_results/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ready</name>
+      <anchorfile>cpp/regex/match_results/ready</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/regex/match_results/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/match_results/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::cerr</name>
+    <filename>cpp/io/basic_ostream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8</name>
+    <filename>cpp/locale/codecvt_utf8</filename>
+    <class kind="class">std::codecvt_utf8::extern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf8::state_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf8::intern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8::extern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8::state_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8::intern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_add</name>
+    <filename>cpp/numeric/ratio/ratio_add</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_move_constructible</name>
+    <filename>cpp/types/is_move_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wcsub_match</name>
+    <filename>cpp/regex/sub_match</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator string_type</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcsub_match</name>
+      <anchorfile>cpp/regex/sub_match/sub_match</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/sub_match/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/regex/sub_match/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_member_pointer</name>
+    <filename>cpp/types/is_member_pointer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wstreampos</name>
+    <filename>cpp/io/fpos</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>state</name>
+      <anchorfile>cpp/io/fpos/state</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_least16_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::tuple</name>
+    <filename>cpp/utility/tuple</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/utility/tuple/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/utility/tuple/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tuple</name>
+      <anchorfile>cpp/utility/tuple/tuple</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::make_signed</name>
+    <filename>cpp/types/make_signed</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::logic_error</name>
+    <filename>cpp/error/logic_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>logic_error</name>
+      <anchorfile>cpp/error/logic_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::sregex_iterator</name>
+    <filename>cpp/regex/regex_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sregex_iterator</name>
+      <anchorfile>cpp/regex/regex_iterator/regex_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::int_least64_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::binary_negate</name>
+    <filename>cpp/utility/functional/binary_negate</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/binary_negate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>binary_negate</name>
+      <anchorfile>cpp/utility/functional/binary_negate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::discard_block_engine</name>
+    <filename>cpp/numeric/random/discard_block_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>base</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>discard_block_engine</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/discard_block_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_assignable</name>
+    <filename>cpp/types/is_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::add_cv</name>
+    <filename>cpp/types/add_cv</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::pico</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::iterator_traits</name>
+    <filename>cpp/iterator/iterator_traits</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_default_constructible</name>
+    <filename>cpp/types/is_default_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::shared_ptr</name>
+    <filename>cpp/memory/shared_ptr</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>shared_ptr</name>
+      <anchorfile>cpp/memory/shared_ptr/shared_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~shared_ptr</name>
+      <anchorfile>cpp/memory/shared_ptr/~shared_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/memory/shared_ptr/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>owner_before</name>
+      <anchorfile>cpp/memory/shared_ptr/owner_before</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/memory/shared_ptr/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/memory/shared_ptr/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/memory/shared_ptr/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unique</name>
+      <anchorfile>cpp/memory/shared_ptr/unique</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/memory/shared_ptr/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/memory/shared_ptr/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/memory/shared_ptr/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_alloc</name>
+    <filename>cpp/memory/new/bad_alloc</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/memory/new/bad_alloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_alloc</name>
+      <anchorfile>cpp/memory/new/bad_alloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostringstream</name>
+    <filename>cpp/io/basic_ostringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_ostringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ostringstream</name>
+      <anchorfile>cpp/io/basic_ostringstream/basic_ostringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ostringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ostringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostringstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_fstream</name>
+    <filename>cpp/io/basic_fstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_fstream</name>
+      <anchorfile>cpp/io/basic_fstream/basic_fstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_fstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_fstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_fstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_fstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_fstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_fstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_fstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_fstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_fstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_fstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::stringbuf</name>
+    <filename>cpp/io/basic_stringbuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>stringbuf</name>
+      <anchorfile>cpp/io/basic_stringbuf/basic_stringbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_stringbuf/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_stringbuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::exponential_distribution</name>
+    <filename>cpp/numeric/random/exponential_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>exponential_distribution</name>
+      <anchorfile>cpp/numeric/random/exponential_distribution/exponential_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/exponential_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/exponential_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/exponential_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/exponential_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/exponential_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lambda</name>
+      <anchorfile>cpp/numeric/random/exponential_distribution/lambda</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint32_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wcregex_iterator</name>
+    <filename>cpp/regex/regex_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcregex_iterator</name>
+      <anchorfile>cpp/regex/regex_iterator/regex_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_function_call</name>
+    <filename>cpp/utility/functional/bad_function_call</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_function_call</name>
+      <anchorfile>cpp/utility/functional/bad_function_call</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::false_type</name>
+    <filename>cpp/types/integral_constant</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wregex</name>
+    <filename>cpp/regex/basic_regex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>wregex</name>
+      <anchorfile>cpp/regex/basic_regex/basic_regex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/basic_regex/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/regex/basic_regex/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/regex/basic_regex/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wregex</name>
+      <anchorfile>cpp/regex/basic_regex/~basic_regex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/basic_regex/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mark_count</name>
+      <anchorfile>cpp/regex/basic_regex/mark_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/regex/basic_regex/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/regex/basic_regex/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_least8_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::uniform_real_distribution</name>
+    <filename>cpp/numeric/random/uniform_real_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>uniform_real_distribution</name>
+      <anchorfile>cpp/numeric/random/uniform_real_distribution/uniform_real_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/uniform_real_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>a</name>
+      <anchorfile>cpp/numeric/random/uniform_real_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/uniform_real_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/uniform_real_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/uniform_real_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>b</name>
+      <anchorfile>cpp/numeric/random/uniform_real_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::smatch</name>
+    <filename>cpp/regex/match_results</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>smatch</name>
+      <anchorfile>cpp/regex/match_results/match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>format</name>
+      <anchorfile>cpp/regex/match_results/format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/regex/match_results/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/match_results/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>position</name>
+      <anchorfile>cpp/regex/match_results/position</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~smatch</name>
+      <anchorfile>cpp/regex/match_results/~match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>prefix</name>
+      <anchorfile>cpp/regex/match_results/prefix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/match_results/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/regex/match_results/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>suffix</name>
+      <anchorfile>cpp/regex/match_results/suffix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/regex/match_results/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/regex/match_results/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ready</name>
+      <anchorfile>cpp/regex/match_results/ready</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/regex/match_results/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/match_results/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::cregex_token_iterator</name>
+    <filename>cpp/regex/regex_token_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cregex_token_iterator</name>
+      <anchorfile>cpp/regex/regex_token_iterator/regex_token_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::range_error</name>
+    <filename>cpp/error/range_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>range_error</name>
+      <anchorfile>cpp/error/range_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_assignable</name>
+    <filename>cpp/types/is_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_copy_assignable</name>
+    <filename>cpp/types/is_copy_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::invalid_argument</name>
+    <filename>cpp/error/invalid_argument</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>invalid_argument</name>
+      <anchorfile>cpp/error/invalid_argument</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_unsigned</name>
+    <filename>cpp/types/is_unsigned</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::jmp_buf</name>
+    <filename>cpp/utility/program/jmp_buf</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_class</name>
+    <filename>cpp/types/is_class</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::geometric_distribution</name>
+    <filename>cpp/numeric/random/geometric_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>p</name>
+      <anchorfile>cpp/numeric/random/geometric_distribution/p</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/geometric_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/geometric_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>geometric_distribution</name>
+      <anchorfile>cpp/numeric/random/geometric_distribution/geometric_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/geometric_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/geometric_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_fast8_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::mersenne_twister_engine</name>
+    <filename>cpp/numeric/random/mersenne_twister_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mersenne_twister_engine</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_arithmetic</name>
+    <filename>cpp/types/is_arithmetic</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::negate</name>
+    <filename>cpp/utility/functional/negate</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/negate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::try_to_lock_t</name>
+    <filename>cpp/thread/lock_tag_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wfilebuf</name>
+    <filename>cpp/io/basic_filebuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_filebuf/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wfilebuf</name>
+      <anchorfile>cpp/io/basic_filebuf/~basic_filebuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wfilebuf</name>
+      <anchorfile>cpp/io/basic_filebuf/basic_filebuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_filebuf/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_filebuf/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_filebuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_compound</name>
+    <filename>cpp/types/is_compound</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::iostream</name>
+    <filename>cpp/io/basic_iostream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~iostream</name>
+      <anchorfile>cpp/io/basic_iostream/~basic_iostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::iostream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::iostream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::iostream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iostream</name>
+      <anchorfile>cpp/io/basic_iostream/basic_iostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::iostream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::iostream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::iostream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_object</name>
+    <filename>cpp/types/is_object</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::recursive_mutex</name>
+    <filename>cpp/thread/recursive_mutex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock</name>
+      <anchorfile>cpp/thread/recursive_mutex/unlock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>native_handle</name>
+      <anchorfile>cpp/thread/recursive_mutex/native_handle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>recursive_mutex</name>
+      <anchorfile>cpp/thread/recursive_mutex/recursive_mutex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/recursive_mutex/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/recursive_mutex/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_copy_constructible</name>
+    <filename>cpp/types/is_copy_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8_utf16</name>
+    <filename>cpp/locale/codecvt_utf8_utf16</filename>
+    <class kind="class">std::codecvt_utf8_utf16::extern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf8_utf16::state_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf8_utf16::intern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8_utf16::extern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8_utf16::state_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf8_utf16::intern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::not_equal_to</name>
+    <filename>cpp/utility/functional/not_equal_to</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/not_equal_to</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_destructible</name>
+    <filename>cpp/types/is_destructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int_fast32_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::rank</name>
+    <filename>cpp/types/rank</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::milli</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::deci</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::add_lvalue_reference</name>
+    <filename>cpp/types/add_reference</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_bind_expression</name>
+    <filename>cpp/utility/functional/is_bind_expression</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ios_base</name>
+    <filename>cpp/io/ios_base</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ios_base::event_callback</class>
+    <class kind="class">std::ios_base::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/ios_base/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ios_base</name>
+      <anchorfile>cpp/io/ios_base/ios_base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~ios_base</name>
+      <anchorfile>cpp/io/ios_base/~ios_base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ios_base::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ios_base::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_less</name>
+    <filename>cpp/numeric/ratio/ratio_less</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int64_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::nullptr_t</name>
+    <filename>cpp/types/nullptr_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::stack</name>
+    <filename>cpp/container/stack</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/stack/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/stack/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/stack/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/stack/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop</name>
+      <anchorfile>cpp/container/stack/pop</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/stack/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~stack</name>
+      <anchorfile>cpp/container/stack/~stack</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>top</name>
+      <anchorfile>cpp/container/stack/top</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>stack</name>
+      <anchorfile>cpp/container/stack/stack</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push</name>
+      <anchorfile>cpp/container/stack/push</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_fast64_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_reference</name>
+    <filename>cpp/types/is_reference</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::shared_future</name>
+    <filename>cpp/thread/shared_future</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~shared_future</name>
+      <anchorfile>cpp/thread/shared_future/~shared_future</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/thread/shared_future/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait</name>
+      <anchorfile>cpp/thread/shared_future/wait</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_until</name>
+      <anchorfile>cpp/thread/shared_future/wait_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_for</name>
+      <anchorfile>cpp/thread/shared_future/wait_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shared_future</name>
+      <anchorfile>cpp/thread/shared_future/shared_future</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>valid</name>
+      <anchorfile>cpp/thread/shared_future/valid</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/thread/shared_future/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::u16streampos</name>
+    <filename>cpp/io/fpos</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>state</name>
+      <anchorfile>cpp/io/fpos/state</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wistream</name>
+    <filename>cpp/io/basic_istream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>wistream</name>
+      <anchorfile>cpp/io/basic_istream/basic_istream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wistream</name>
+      <anchorfile>cpp/io/basic_istream/~basic_istream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wistream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wistream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wistream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::aligned_storage</name>
+    <filename>cpp/types/aligned_storage</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wstreambuf</name>
+    <filename>cpp/io/basic_streambuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wstreambuf</name>
+      <anchorfile>cpp/io/basic_streambuf/basic_streambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wstreambuf</name>
+      <anchorfile>cpp/io/basic_streambuf/~basic_streambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_streambuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::binary_function</name>
+    <filename>cpp/utility/functional/binary_function</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::out_of_range</name>
+    <filename>cpp/error/out_of_range</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>out_of_range</name>
+      <anchorfile>cpp/error/out_of_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::independent_bits_engine</name>
+    <filename>cpp/numeric/random/independent_bits_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/independent_bits_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/independent_bits_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>independent_bits_engine</name>
+      <anchorfile>cpp/numeric/random/independent_bits_engine/independent_bits_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/independent_bits_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>base</name>
+      <anchorfile>cpp/numeric/random/independent_bits_engine/base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/independent_bits_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/independent_bits_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::stringstream</name>
+    <filename>cpp/io/basic_stringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_stringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>stringstream</name>
+      <anchorfile>cpp/io/basic_stringstream/basic_stringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::stringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::stringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::stringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_stringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::stringstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::stringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::stringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::tera</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::recursive_timed_mutex</name>
+    <filename>cpp/thread/recursive_timed_mutex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock</name>
+      <anchorfile>cpp/thread/recursive_timed_mutex/unlock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>native_handle</name>
+      <anchorfile>cpp/thread/recursive_timed_mutex/native_handle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_until</name>
+      <anchorfile>cpp/thread/recursive_timed_mutex/try_lock_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_for</name>
+      <anchorfile>cpp/thread/recursive_timed_mutex/try_lock_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>recursive_timed_mutex</name>
+      <anchorfile>cpp/thread/recursive_timed_mutex/recursive_timed_mutex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/recursive_timed_mutex/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/recursive_timed_mutex/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::nano</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::unordered_multimap</name>
+    <filename>cpp/container/unordered_multimap</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~unordered_multimap</name>
+      <anchorfile>cpp/container/unordered_multimap/~unordered_multimap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_bucket_count</name>
+      <anchorfile>cpp/container/unordered_multimap/max_bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_count</name>
+      <anchorfile>cpp/container/unordered_multimap/bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/unordered_multimap/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/unordered_multimap/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/unordered_multimap/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unordered_multimap</name>
+      <anchorfile>cpp/container/unordered_multimap/unordered_multimap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_load_factor</name>
+      <anchorfile>cpp/container/unordered_multimap/max_load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/unordered_multimap/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/unordered_multimap/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end(int)</name>
+      <anchorfile>cpp/container/unordered_multimap/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_eq</name>
+      <anchorfile>cpp/container/unordered_multimap/key_eq</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hash_function</name>
+      <anchorfile>cpp/container/unordered_multimap/hash_function</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/unordered_multimap/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/unordered_multimap/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin(int)</name>
+      <anchorfile>cpp/container/unordered_multimap/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/unordered_multimap/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin(int)</name>
+      <anchorfile>cpp/container/unordered_multimap/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>load_factor</name>
+      <anchorfile>cpp/container/unordered_multimap/load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/unordered_multimap/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/unordered_multimap/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/unordered_multimap/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/container/unordered_multimap/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rehash</name>
+      <anchorfile>cpp/container/unordered_multimap/rehash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket</name>
+      <anchorfile>cpp/container/unordered_multimap/bucket</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/unordered_multimap/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/unordered_multimap/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/unordered_multimap/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend(int)</name>
+      <anchorfile>cpp/container/unordered_multimap/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/unordered_multimap/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/unordered_multimap/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/unordered_multimap/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/unordered_multimap/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_size</name>
+      <anchorfile>cpp/container/unordered_multimap/bucket_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::normal_distribution</name>
+    <filename>cpp/numeric/random/normal_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>stddev</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mean</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>normal_distribution</name>
+      <anchorfile>cpp/numeric/random/normal_distribution/normal_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::minstd_rand</name>
+    <filename>cpp/numeric/random/linear_congruential_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>minstd_rand</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/linear_congruential_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_signed</name>
+    <filename>cpp/types/is_signed</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_move_constructible</name>
+    <filename>cpp/types/is_move_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::unique_ptr</name>
+    <filename>cpp/memory/unique_ptr</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>unique_ptr</name>
+      <anchorfile>cpp/memory/unique_ptr/unique_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/memory/unique_ptr/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/memory/unique_ptr/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/memory/unique_ptr/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~unique_ptr</name>
+      <anchorfile>cpp/memory/unique_ptr/~unique_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/memory/unique_ptr/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>release</name>
+      <anchorfile>cpp/memory/unique_ptr/release</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_deleter</name>
+      <anchorfile>cpp/memory/unique_ptr/get_deleter</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/memory/unique_ptr/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/memory/unique_ptr/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/memory/unique_ptr/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_copy_constructible</name>
+    <filename>cpp/types/is_copy_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::forward_list</name>
+    <filename>cpp/container/forward_list</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_front</name>
+      <anchorfile>cpp/container/forward_list/pop_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unique</name>
+      <anchorfile>cpp/container/forward_list/unique</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sort</name>
+      <anchorfile>cpp/container/forward_list/sort</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/forward_list/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>splice_after</name>
+      <anchorfile>cpp/container/forward_list/splice_after</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reverse</name>
+      <anchorfile>cpp/container/forward_list/reverse</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>remove_if</name>
+      <anchorfile>cpp/container/forward_list/remove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/forward_list/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>remove</name>
+      <anchorfile>cpp/container/forward_list/remove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push_front</name>
+      <anchorfile>cpp/container/forward_list/push_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_after</name>
+      <anchorfile>cpp/container/forward_list/emplace_after</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/forward_list/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/container/forward_list/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/forward_list/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/container/forward_list/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_front</name>
+      <anchorfile>cpp/container/forward_list/emplace_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/forward_list/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase_after</name>
+      <anchorfile>cpp/container/forward_list/erase_after</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/container/forward_list/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>forward_list</name>
+      <anchorfile>cpp/container/forward_list/forward_list</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~forward_list</name>
+      <anchorfile>cpp/container/forward_list/~forward_list</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>before_begin</name>
+      <anchorfile>cpp/container/forward_list/before_begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbefore_begin</name>
+      <anchorfile>cpp/container/forward_list/before_begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>merge</name>
+      <anchorfile>cpp/container/forward_list/merge</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/forward_list/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert_after</name>
+      <anchorfile>cpp/container/forward_list/insert_after</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/forward_list/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/forward_list/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/forward_list/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/forward_list/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::errc</name>
+    <filename>cpp/error/errc</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::lconv</name>
+    <filename>cpp/locale/lconv</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::strstreambuf</name>
+    <filename>cpp/io/strstreambuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/strstreambuf/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pcount</name>
+      <anchorfile>cpp/io/strstreambuf/pcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~strstreambuf</name>
+      <anchorfile>cpp/io/strstreambuf/~strstreambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>freeze</name>
+      <anchorfile>cpp/io/strstreambuf/freeze</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strstreambuf</name>
+      <anchorfile>cpp/io/strstreambuf/strstreambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::locale</name>
+    <filename>cpp/locale/locale</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>name</name>
+      <anchorfile>cpp/locale/locale/name</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>combine</name>
+      <anchorfile>cpp/locale/locale/combine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/locale/locale/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>classic</name>
+      <anchorfile>cpp/locale/locale/classic</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>global</name>
+      <anchorfile>cpp/locale/locale/global</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/locale/locale/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/locale/locale/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::locale::facet</class>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/locale/locale/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>locale</name>
+      <anchorfile>cpp/locale/locale/locale</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::locale::id</class>
+    <member kind="function">
+      <type>T</type>
+      <name>~locale</name>
+      <anchorfile>cpp/locale/locale/~locale</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::locale::facet</name>
+    <filename>cpp/locale/locale/facet</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>facet</name>
+      <anchorfile>cpp/locale/locale/facet/facet</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::locale::id</name>
+    <filename>cpp/locale/locale/id</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>id</name>
+      <anchorfile>cpp/locale/locale/id/id</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::equal_to</name>
+    <filename>cpp/utility/functional/equal_to</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/equal_to</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::divides</name>
+    <filename>cpp/utility/functional/divides</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/divides</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::collate_byname</name>
+    <filename>cpp/locale/collate_byname</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>hash</name>
+      <anchorfile>cpp/locale/collate/hash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_hash</name>
+      <anchorfile>cpp/locale/collate/hash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::collate_byname::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_transform</name>
+      <anchorfile>cpp/locale/collate/transform</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>transform</name>
+      <anchorfile>cpp/locale/collate/transform</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_compare</name>
+      <anchorfile>cpp/locale/collate/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~collate_byname</name>
+      <anchorfile>cpp/locale/collate_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::collate_byname::string_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>collate_byname</name>
+      <anchorfile>cpp/locale/collate_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/locale/collate/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::collate_byname::char_type</name>
+    <filename>cpp/locale/collate</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::collate_byname::string_type</name>
+    <filename>cpp/locale/collate</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::domain_error</name>
+    <filename>cpp/error/domain_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>domain_error</name>
+      <anchorfile>cpp/error/domain_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_empty</name>
+    <filename>cpp/types/is_empty</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_default_constructible</name>
+    <filename>cpp/types/is_default_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_equal</name>
+    <filename>cpp/numeric/ratio/ratio_equal</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ostream</name>
+    <filename>cpp/io/basic_ostream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>ostream</name>
+      <anchorfile>cpp/io/basic_ostream/basic_ostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~ostream</name>
+      <anchorfile>cpp/io/basic_ostream/~basic_ostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ostream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::streamsize</name>
+    <filename>cpp/io/streamsize</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::shared_lock</name>
+    <filename>cpp/thread/shared_lock</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>mutex</name>
+      <anchorfile>cpp/thread/shared_lock/mutex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/thread/shared_lock/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shared_lock</name>
+      <anchorfile>cpp/thread/shared_lock/shared_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_for</name>
+      <anchorfile>cpp/thread/shared_lock/try_lock_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>release</name>
+      <anchorfile>cpp/thread/shared_lock/release</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/shared_lock/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/thread/shared_lock/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock</name>
+      <anchorfile>cpp/thread/shared_lock/unlock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/thread/shared_lock/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~shared_lock</name>
+      <anchorfile>cpp/thread/shared_lock/~shared_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_until</name>
+      <anchorfile>cpp/thread/shared_lock/try_lock_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/shared_lock/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>owns_lock</name>
+      <anchorfile>cpp/thread/shared_lock/owns_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint8_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::enable_shared_from_this</name>
+    <filename>cpp/memory/enable_shared_from_this</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>enable_shared_from_this</name>
+      <anchorfile>cpp/memory/enable_shared_from_this/enable_shared_from_this</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/memory/enable_shared_from_this/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shared_from_this</name>
+      <anchorfile>cpp/memory/enable_shared_from_this/shared_from_this</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~enable_shared_from_this</name>
+      <anchorfile>cpp/memory/enable_shared_from_this/~enable_shared_from_this</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ptrdiff_t</name>
+    <filename>cpp/types/ptrdiff_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int_fast8_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::aligned_union</name>
+    <filename>cpp/types/aligned_union</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::future</name>
+    <filename>cpp/thread/future</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/thread/future/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait</name>
+      <anchorfile>cpp/thread/future/wait</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_until</name>
+      <anchorfile>cpp/thread/future/wait_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wait_for</name>
+      <anchorfile>cpp/thread/future/wait_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~future</name>
+      <anchorfile>cpp/thread/future/~future</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>share</name>
+      <anchorfile>cpp/thread/future/share</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>future</name>
+      <anchorfile>cpp/thread/future/future</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>valid</name>
+      <anchorfile>cpp/thread/future/valid</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/thread/future/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wcmatch</name>
+    <filename>cpp/regex/match_results</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>wcmatch</name>
+      <anchorfile>cpp/regex/match_results/match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>format</name>
+      <anchorfile>cpp/regex/match_results/format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/regex/match_results/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/match_results/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>position</name>
+      <anchorfile>cpp/regex/match_results/position</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>prefix</name>
+      <anchorfile>cpp/regex/match_results/prefix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/match_results/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/regex/match_results/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>suffix</name>
+      <anchorfile>cpp/regex/match_results/suffix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/regex/match_results/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/regex/match_results/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wcmatch</name>
+      <anchorfile>cpp/regex/match_results/~match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ready</name>
+      <anchorfile>cpp/regex/match_results/ready</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/regex/match_results/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/match_results/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::overflow_error</name>
+    <filename>cpp/error/overflow_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow_error</name>
+      <anchorfile>cpp/error/overflow_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::centi</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wssub_match</name>
+    <filename>cpp/regex/sub_match</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator string_type</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wssub_match</name>
+      <anchorfile>cpp/regex/sub_match/sub_match</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/sub_match/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/regex/sub_match/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_move_assignable</name>
+    <filename>cpp/types/is_move_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::pair</name>
+    <filename>cpp/utility/pair</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pair</name>
+      <anchorfile>cpp/utility/pair/pair</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/utility/pair/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/utility/pair/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wsregex_token_iterator</name>
+    <filename>cpp/regex/regex_token_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wsregex_token_iterator</name>
+      <anchorfile>cpp/regex/regex_token_iterator/regex_token_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::weibull_distribution</name>
+    <filename>cpp/numeric/random/weibull_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>a</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>weibull_distribution</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/weibull_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>b</name>
+      <anchorfile>cpp/numeric/random/weibull_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::less</name>
+    <filename>cpp/utility/functional/less</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/less</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::multiplies</name>
+    <filename>cpp/utility/functional/multiplies</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/multiplies</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_enum</name>
+    <filename>cpp/types/is_enum</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::unary_function</name>
+    <filename>cpp/utility/functional/unary_function</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::error_code</name>
+    <filename>cpp/error/error_code</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>value</name>
+      <anchorfile>cpp/error/error_code/value</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/error/error_code/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/error/error_code/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/error/error_code/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>error_code</name>
+      <anchorfile>cpp/error/error_code/error_code</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/error/error_code/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>default_error_condition</name>
+      <anchorfile>cpp/error/error_code/default_error_condition</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>message</name>
+      <anchorfile>cpp/error/error_code/message</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>category</name>
+      <anchorfile>cpp/error/error_code/category</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::yocto</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::streampos</name>
+    <filename>cpp/io/fpos</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>state</name>
+      <anchorfile>cpp/io/fpos/state</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::istream_iterator</name>
+    <filename>cpp/iterator/istream_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wifstream</name>
+    <filename>cpp/io/basic_ifstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_ifstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ifstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wifstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_ifstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wifstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_ifstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wifstream</name>
+      <anchorfile>cpp/io/basic_ifstream/basic_ifstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wifstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wifstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wifstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wifstream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct_byname</name>
+    <filename>cpp/locale/moneypunct_byname</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_curr_symbol</name>
+      <anchorfile>cpp/locale/moneypunct/curr_symbol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_decimal_point</name>
+      <anchorfile>cpp/locale/moneypunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>thousands_sep</name>
+      <anchorfile>cpp/locale/moneypunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>moneypunct_byname</name>
+      <anchorfile>cpp/locale/moneypunct_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>curr_symbol</name>
+      <anchorfile>cpp/locale/moneypunct/curr_symbol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_thousands_sep</name>
+      <anchorfile>cpp/locale/moneypunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>positive_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>frac_digits</name>
+      <anchorfile>cpp/locale/moneypunct/frac_digits</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_negative_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pos_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_pos_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>neg_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>negative_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>grouping</name>
+      <anchorfile>cpp/locale/moneypunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_frac_digits</name>
+      <anchorfile>cpp/locale/moneypunct/frac_digits</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>decimal_point</name>
+      <anchorfile>cpp/locale/moneypunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_neg_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::moneypunct_byname::string_type</class>
+    <class kind="class">std::moneypunct_byname::pattern</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_positive_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::moneypunct_byname::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>~moneypunct_byname</name>
+      <anchorfile>cpp/locale/moneypunct_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_grouping</name>
+      <anchorfile>cpp/locale/moneypunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct_byname::string_type</name>
+    <filename>cpp/locale/moneypunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct_byname::pattern</name>
+    <filename>cpp/locale/money_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct_byname::char_type</name>
+    <filename>cpp/locale/moneypunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::terminate_handler</name>
+    <filename>cpp/error/terminate_handler</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ctype_base</name>
+    <filename>cpp/locale/ctype_base</filename>
+    <class kind="class">std::ctype_base::mask</class>
+  </compound>
+  <compound kind="class">
+    <name>std::ctype_base::mask</name>
+    <filename>cpp/locale/ctype_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::reference_wrapper</name>
+    <filename>cpp/utility/functional/reference_wrapper</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/utility/functional/reference_wrapper/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/reference_wrapper/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/utility/functional/reference_wrapper/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reference_wrapper</name>
+      <anchorfile>cpp/utility/functional/reference_wrapper/reference_wrapper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator T&amp;</name>
+      <anchorfile>cpp/utility/functional/reference_wrapper/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ranlux48_base</name>
+    <filename>cpp/numeric/random/subtract_with_carry_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ranlux48_base</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bit_not</name>
+    <filename>cpp/utility/functional/bit_not</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/bit_not</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::int_fast16_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::error_category</name>
+    <filename>cpp/error/error_category</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>name</name>
+      <anchorfile>cpp/error/error_category/name</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/error/error_category/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;</name>
+      <anchorfile>cpp/error/error_category/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>error_category</name>
+      <anchorfile>cpp/error/error_category/error_category</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equivalent</name>
+      <anchorfile>cpp/error/error_category/equivalent</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/error/error_category/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~error_category</name>
+      <anchorfile>cpp/error/error_category/~error_category</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>default_error_condition</name>
+      <anchorfile>cpp/error/error_category/default_error_condition</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>message</name>
+      <anchorfile>cpp/error/error_category/message</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::regex_traits</name>
+    <filename>cpp/regex/regex_traits</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>value</name>
+      <anchorfile>cpp/regex/regex_traits/value</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lookup_collatename</name>
+      <anchorfile>cpp/regex/regex_traits/lookup_collatename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>isctype</name>
+      <anchorfile>cpp/regex/regex_traits/isctype</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/regex/regex_traits/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>regex_traits</name>
+      <anchorfile>cpp/regex/regex_traits/regex_traits</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>transform_primary</name>
+      <anchorfile>cpp/regex/regex_traits/transform_primary</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>translate</name>
+      <anchorfile>cpp/regex/regex_traits/translate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/regex/regex_traits/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lookup_classname</name>
+      <anchorfile>cpp/regex/regex_traits/lookup_classname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>transform</name>
+      <anchorfile>cpp/regex/regex_traits/transform</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/regex_traits/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>translate_nocase</name>
+      <anchorfile>cpp/regex/regex_traits/translate_nocase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="namespace">
+    <name>std::regex_constants</name>
+    <filename></filename>
+  </compound>
+  <compound kind="class">
+    <name>std::negative_binomial_distribution</name>
+    <filename>cpp/numeric/random/negative_binomial_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>p</name>
+      <anchorfile>cpp/numeric/random/negative_binomial_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>negative_binomial_distribution</name>
+      <anchorfile>cpp/numeric/random/negative_binomial_distribution/negative_binomial_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/negative_binomial_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/negative_binomial_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/negative_binomial_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/negative_binomial_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>k</name>
+      <anchorfile>cpp/numeric/random/negative_binomial_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_union</name>
+    <filename>cpp/types/is_union</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::mt19937</name>
+    <filename>cpp/numeric/random/mersenne_twister_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>mt19937</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/mersenne_twister_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::enable_if</name>
+    <filename>cpp/types/enable_if</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::chi_squared_distribution</name>
+    <filename>cpp/numeric/random/chi_squared_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>n</name>
+      <anchorfile>cpp/numeric/random/chi_squared_distribution/n</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/chi_squared_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/chi_squared_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/chi_squared_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/chi_squared_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/chi_squared_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>chi_squared_distribution</name>
+      <anchorfile>cpp/numeric/random/chi_squared_distribution/chi_squared_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::add_rvalue_reference</name>
+    <filename>cpp/types/add_reference</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istream</name>
+    <filename>cpp/io/basic_istream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_istream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_istream</name>
+      <anchorfile>cpp/io/basic_istream/basic_istream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~basic_istream</name>
+      <anchorfile>cpp/io/basic_istream/~basic_istream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_istream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_istream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostream_iterator</name>
+    <filename>cpp/iterator/ostream_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_copy_assignable</name>
+    <filename>cpp/types/is_copy_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::clog</name>
+    <filename>cpp/io/basic_ostream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_scalar</name>
+    <filename>cpp/types/is_scalar</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::uses_allocator</name>
+    <filename>cpp/memory/uses_allocator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::piecewise_linear_distribution</name>
+    <filename>cpp/numeric/random/piecewise_linear_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>piecewise_linear_distribution</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/piecewise_linear_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>densities</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>intervals</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/piecewise_linear_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::hash</name>
+    <filename>cpp/utility/hash</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>hash</name>
+      <anchorfile>cpp/utility/hash/hash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/hash/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::shuffle_order_engine</name>
+    <filename>cpp/numeric/random/shuffle_order_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shuffle_order_engine</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/shuffle_order_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>base</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="namespace">
+    <name>std::chrono</name>
+    <filename></filename>
+    <class kind="class">std::chrono::minutes</class>
+    <member kind="function">
+      <type>T</type>
+      <name>time_point_cast</name>
+      <anchorfile>cpp/chrono/time_point/time_point_cast</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::chrono::seconds</class>
+    <class kind="class">std::chrono::treat_as_floating_point</class>
+    <class kind="class">std::chrono::duration</class>
+    <class kind="class">std::chrono::milliseconds</class>
+    <class kind="class">std::chrono::steady_clock</class>
+    <class kind="class">std::chrono::system_clock</class>
+    <class kind="class">std::chrono::hours</class>
+    <class kind="class">std::chrono::time_point</class>
+    <class kind="class">std::chrono::high_resolution_clock</class>
+    <class kind="class">std::chrono::duration_values</class>
+    <class kind="class">std::chrono::microseconds</class>
+    <class kind="class">std::chrono::nanoseconds</class>
+    <member kind="function">
+      <type>T</type>
+      <name>duration_cast</name>
+      <anchorfile>cpp/chrono/duration/duration_cast</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::minutes</name>
+    <filename>cpp/chrono/duration</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>minutes</name>
+      <anchorfile>cpp/chrono/duration/duration</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/chrono/duration/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/chrono/duration/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator%=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::seconds</name>
+    <filename>cpp/chrono/duration</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/chrono/duration/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/chrono/duration/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator%=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seconds</name>
+      <anchorfile>cpp/chrono/duration/duration</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::treat_as_floating_point</name>
+    <filename>cpp/chrono/treat_as_floating_point</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::duration</name>
+    <filename>cpp/chrono/duration</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/chrono/duration/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>duration</name>
+      <anchorfile>cpp/chrono/duration/duration</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/chrono/duration/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator%=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::milliseconds</name>
+    <filename>cpp/chrono/duration</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>milliseconds</name>
+      <anchorfile>cpp/chrono/duration/duration</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/chrono/duration/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/chrono/duration/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator%=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::steady_clock</name>
+    <filename>cpp/chrono/steady_clock</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>now</name>
+      <anchorfile>cpp/chrono/steady_clock/now</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::system_clock</name>
+    <filename>cpp/chrono/system_clock</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>now</name>
+      <anchorfile>cpp/chrono/system_clock/now</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_time_t</name>
+      <anchorfile>cpp/chrono/system_clock/to_time_t</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>from_time_t</name>
+      <anchorfile>cpp/chrono/system_clock/from_time_t</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::hours</name>
+    <filename>cpp/chrono/duration</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/chrono/duration/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hours</name>
+      <anchorfile>cpp/chrono/duration/duration</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/chrono/duration/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator%=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::time_point</name>
+    <filename>cpp/chrono/time_point</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>time_since_epoch</name>
+      <anchorfile>cpp/chrono/time_point/time_since_epoch</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/time_point/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/time_point/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/time_point/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/time_point/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>time_point</name>
+      <anchorfile>cpp/chrono/time_point/time_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::high_resolution_clock</name>
+    <filename>cpp/chrono/high_resolution_clock</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>now</name>
+      <anchorfile>cpp/chrono/high_resolution_clock/now</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::duration_values</name>
+    <filename>cpp/chrono/duration_values</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration_values/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration_values/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration_values/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::microseconds</name>
+    <filename>cpp/chrono/duration</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/chrono/duration/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/chrono/duration/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator%=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>microseconds</name>
+      <anchorfile>cpp/chrono/duration/duration</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::chrono::nanoseconds</name>
+    <filename>cpp/chrono/duration</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/chrono/duration/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>zero</name>
+      <anchorfile>cpp/chrono/duration/zero</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/chrono/duration/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/chrono/duration/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+</name>
+      <anchorfile>cpp/chrono/duration/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/chrono/duration/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator%=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/chrono/duration/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>nanoseconds</name>
+      <anchorfile>cpp/chrono/duration/duration</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/chrono/duration/operator_arith3</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::greater</name>
+    <filename>cpp/utility/functional/greater</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/greater</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::csub_match</name>
+    <filename>cpp/regex/sub_match</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>csub_match</name>
+      <anchorfile>cpp/regex/sub_match/sub_match</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator string_type</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/sub_match/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/regex/sub_match/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uintmax_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::remove_pointer</name>
+    <filename>cpp/types/remove_pointer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::numeric_limits</name>
+    <filename>cpp/types/numeric_limits</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>lowest</name>
+      <anchorfile>cpp/types/numeric_limits/lowest</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>infinity</name>
+      <anchorfile>cpp/types/numeric_limits/infinity</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>signaling_NaN</name>
+      <anchorfile>cpp/types/numeric_limits/signaling_NaN</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>quiet_NaN</name>
+      <anchorfile>cpp/types/numeric_limits/quiet_NaN</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>denorm_min</name>
+      <anchorfile>cpp/types/numeric_limits/denorm_min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/types/numeric_limits/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>round_error</name>
+      <anchorfile>cpp/types/numeric_limits/round_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/types/numeric_limits/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epsilon</name>
+      <anchorfile>cpp/types/numeric_limits/epsilon</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::add_volatile</name>
+    <filename>cpp/types/add_cv</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::once_flag</name>
+    <filename>cpp/thread/once_flag</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>once_flag</name>
+      <anchorfile>cpp/thread/once_flag</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_literal_type</name>
+    <filename>cpp/types/is_literal_type</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_base</name>
+    <filename>cpp/locale/money_base</filename>
+    <class kind="class">std::money_base::pattern</class>
+  </compound>
+  <compound kind="class">
+    <name>std::money_base::pattern</name>
+    <filename>cpp/locale/money_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::peta</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_placeholder</name>
+    <filename>cpp/utility/functional/is_placeholder</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::add_const</name>
+    <filename>cpp/types/add_cv</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_stringbuf</name>
+    <filename>cpp/io/basic_stringbuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_stringbuf/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_stringbuf</name>
+      <anchorfile>cpp/io/basic_stringbuf/basic_stringbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_stringbuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::tm</name>
+    <filename>cpp/chrono/c/tm</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_abstract</name>
+    <filename>cpp/types/is_abstract</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::deque</name>
+    <filename>cpp/container/deque</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_front</name>
+      <anchorfile>cpp/container/deque/pop_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/container/deque/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shrink_to_fit</name>
+      <anchorfile>cpp/container/deque/shrink_to_fit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/deque/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/deque/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/deque/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~deque</name>
+      <anchorfile>cpp/container/deque/~deque</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/container/deque/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/deque/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push_front</name>
+      <anchorfile>cpp/container/deque/push_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_back</name>
+      <anchorfile>cpp/container/deque/emplace_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/container/deque/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/deque/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/container/deque/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>deque</name>
+      <anchorfile>cpp/container/deque/deque</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/deque/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/container/deque/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_front</name>
+      <anchorfile>cpp/container/deque/emplace_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/deque/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/deque/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/container/deque/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/deque/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/deque/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/deque/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/deque/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/deque/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/deque/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/deque/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/deque/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/container/deque/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/deque/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/container/deque/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/deque/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::allocator</name>
+    <filename>cpp/memory/allocator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>allocator</name>
+      <anchorfile>cpp/memory/allocator/allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>allocate</name>
+      <anchorfile>cpp/memory/allocator/allocate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>destroy</name>
+      <anchorfile>cpp/memory/allocator/destroy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~allocator</name>
+      <anchorfile>cpp/memory/allocator/~allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/memory/allocator/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>address</name>
+      <anchorfile>cpp/memory/allocator/address</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>deallocate</name>
+      <anchorfile>cpp/memory/allocator/deallocate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>construct</name>
+      <anchorfile>cpp/memory/allocator/construct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::scoped_allocator_adaptor</name>
+    <filename>cpp/memory/scoped_allocator_adaptor</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>deallocate</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/deallocate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>scoped_allocator_adaptor</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/scoped_allocator_adaptor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>destroy</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/destroy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>construct</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/construct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>inner_allocator</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/inner_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>select_on_container_copy_construction</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/select_on_container_copy_construction</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>allocate</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/allocate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>outer_allocator</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/outer_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~scoped_allocator_adaptor</name>
+      <anchorfile>cpp/memory/scoped_allocator_adaptor/~scoped_allocator_adaptor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ssub_match</name>
+    <filename>cpp/regex/sub_match</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator string_type</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ssub_match</name>
+      <anchorfile>cpp/regex/sub_match/sub_match</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/sub_match/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/regex/sub_match/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::messages_byname</name>
+    <filename>cpp/locale/messages_byname</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get</name>
+      <anchorfile>cpp/locale/messages/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::messages_byname::char_type</class>
+    <class kind="class">std::messages_byname::catalog</class>
+    <member kind="function">
+      <type>T</type>
+      <name>~messages_byname</name>
+      <anchorfile>cpp/locale/messages_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>messages_byname</name>
+      <anchorfile>cpp/locale/messages_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_open</name>
+      <anchorfile>cpp/locale/messages/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_close</name>
+      <anchorfile>cpp/locale/messages/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/locale/messages/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::messages_byname::string_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/locale/messages/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/locale/messages/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::messages_byname::char_type</name>
+    <filename>cpp/locale/messages</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::messages_byname::catalog</name>
+    <filename>cpp/locale/messages_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::messages_byname::string_type</name>
+    <filename>cpp/locale/messages</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::promise</name>
+    <filename>cpp/thread/promise</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>set_exception</name>
+      <anchorfile>cpp/thread/promise/set_exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/thread/promise/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/thread/promise/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_exception_at_thread_exit</name>
+      <anchorfile>cpp/thread/promise/set_exception_at_thread_exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_value</name>
+      <anchorfile>cpp/thread/promise/set_value</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_future</name>
+      <anchorfile>cpp/thread/promise/get_future</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>promise</name>
+      <anchorfile>cpp/thread/promise/promise</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~promise</name>
+      <anchorfile>cpp/thread/promise/~promise</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_value_at_thread_exit</name>
+      <anchorfile>cpp/thread/promise/set_value_at_thread_exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::add_pointer</name>
+    <filename>cpp/types/add_pointer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::uintptr_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::bit_and</name>
+    <filename>cpp/utility/functional/bit_and</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/bit_and</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uniform_int_distribution</name>
+    <filename>cpp/numeric/random/uniform_int_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>b</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>a</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uniform_int_distribution</name>
+      <anchorfile>cpp/numeric/random/uniform_int_distribution/uniform_int_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::type_info</name>
+    <filename>cpp/types/type_info</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/types/type_info/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>before</name>
+      <anchorfile>cpp/types/type_info/before</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>name</name>
+      <anchorfile>cpp/types/type_info/name</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/types/type_info/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hash_code</name>
+      <anchorfile>cpp/types/type_info/hash_code</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::fisher_f_distribution</name>
+    <filename>cpp/numeric/random/fisher_f_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>fisher_f_distribution</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/fisher_f_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>n</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>m</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/fisher_f_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::strstream</name>
+    <filename>cpp/io/strstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/strstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pcount</name>
+      <anchorfile>cpp/io/strstream/pcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::strstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::strstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::strstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>strstream</name>
+      <anchorfile>cpp/io/strstream/strstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>freeze</name>
+      <anchorfile>cpp/io/strstream/freeze</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~strstream</name>
+      <anchorfile>cpp/io/strstream/~strstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::strstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::strstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::strstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::time_get_byname</name>
+    <filename>cpp/locale/time_get_byname</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get</name>
+      <anchorfile>cpp/locale/time_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_monthname</name>
+      <anchorfile>cpp/locale/time_get/get_monthname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_weekday</name>
+      <anchorfile>cpp/locale/time_get/get_weekday</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_time</name>
+      <anchorfile>cpp/locale/time_get/get_time</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>time_get_byname</name>
+      <anchorfile>cpp/locale/time_get_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_year</name>
+      <anchorfile>cpp/locale/time_get/get_year</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_get_byname::iter_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get_monthname</name>
+      <anchorfile>cpp/locale/time_get/get_monthname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~time_get_byname</name>
+      <anchorfile>cpp/locale/time_get_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_time</name>
+      <anchorfile>cpp/locale/time_get/get_time</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::time_get_byname::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_date</name>
+      <anchorfile>cpp/locale/time_get/get_date</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_date</name>
+      <anchorfile>cpp/locale/time_get/get_date</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_date_order</name>
+      <anchorfile>cpp/locale/time_get/date_order</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_year</name>
+      <anchorfile>cpp/locale/time_get/get_year</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>date_order</name>
+      <anchorfile>cpp/locale/time_get/date_order</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/locale/time_get/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get_weekday</name>
+      <anchorfile>cpp/locale/time_get/get_weekday</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::time_get_byname::iter_type</name>
+    <filename>cpp/locale/time_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_get_byname::char_type</name>
+    <filename>cpp/locale/time_get</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_streambuf</name>
+    <filename>cpp/io/basic_streambuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_streambuf</name>
+      <anchorfile>cpp/io/basic_streambuf/basic_streambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_streambuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~basic_streambuf</name>
+      <anchorfile>cpp/io/basic_streambuf/~basic_streambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_constructible</name>
+    <filename>cpp/types/is_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::queue</name>
+    <filename>cpp/container/queue</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/queue/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/queue/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/queue/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/queue/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~queue</name>
+      <anchorfile>cpp/container/queue/~queue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop</name>
+      <anchorfile>cpp/container/queue/pop</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/container/queue/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push</name>
+      <anchorfile>cpp/container/queue/push</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>queue</name>
+      <anchorfile>cpp/container/queue/queue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/container/queue/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/queue/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_base_of</name>
+    <filename>cpp/types/is_base_of</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::intmax_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ranlux24</name>
+    <filename>cpp/numeric/random/discard_block_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ranlux24</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/discard_block_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>base</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/discard_block_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::remove_cv</name>
+    <filename>cpp/types/remove_cv</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_destructible</name>
+    <filename>cpp/types/is_destructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wcin</name>
+    <filename>cpp/io/basic_istream</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::atomic</name>
+    <filename>cpp/atomic/atomic</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>store</name>
+      <anchorfile>cpp/atomic/atomic/store</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare_exchange_strong</name>
+      <anchorfile>cpp/atomic/atomic/compare_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>load</name>
+      <anchorfile>cpp/atomic/atomic/load</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--(int)</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fetch_or</name>
+      <anchorfile>cpp/atomic/atomic/fetch_or</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fetch_xor</name>
+      <anchorfile>cpp/atomic/atomic/fetch_xor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator^=</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator|=</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare_exchange_weak</name>
+      <anchorfile>cpp/atomic/atomic/compare_exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fetch_add</name>
+      <anchorfile>cpp/atomic/atomic/fetch_add</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&amp;=</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator--</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic</name>
+      <anchorfile>cpp/atomic/atomic/atomic</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fetch_and</name>
+      <anchorfile>cpp/atomic/atomic/fetch_and</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exchange</name>
+      <anchorfile>cpp/atomic/atomic/exchange</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator T</name>
+      <anchorfile>cpp/atomic/atomic/operator_T</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/atomic/atomic/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/atomic/atomic/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fetch_sub</name>
+      <anchorfile>cpp/atomic/atomic/fetch_sub</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_lock_free</name>
+      <anchorfile>cpp/atomic/atomic/is_lock_free</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_stringstream</name>
+    <filename>cpp/io/basic_stringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_stringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_stringstream</name>
+      <anchorfile>cpp/io/basic_stringstream/basic_stringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_stringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_stringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_stringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_stringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_stringstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_stringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_stringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_void</name>
+    <filename>cpp/types/is_void</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::plus</name>
+    <filename>cpp/utility/functional/plus</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/plus</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bitset</name>
+    <filename>cpp/utility/bitset</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>none</name>
+      <anchorfile>cpp/utility/bitset/all_any_none</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/utility/bitset/operator_ltltgtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/utility/bitset/operator_ltltgtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::bitset::reference</class>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/utility/bitset/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/utility/bitset/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;=</name>
+      <anchorfile>cpp/utility/bitset/operator_ltltgtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator|=</name>
+      <anchorfile>cpp/utility/bitset/operator_logic</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&amp;=</name>
+      <anchorfile>cpp/utility/bitset/operator_logic</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bitset</name>
+      <anchorfile>cpp/utility/bitset/bitset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/utility/bitset/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set</name>
+      <anchorfile>cpp/utility/bitset/set</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>all</name>
+      <anchorfile>cpp/utility/bitset/all_any_none</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_string</name>
+      <anchorfile>cpp/utility/bitset/to_string</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/utility/bitset/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>any</name>
+      <anchorfile>cpp/utility/bitset/all_any_none</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>test</name>
+      <anchorfile>cpp/utility/bitset/test</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/utility/bitset/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;=</name>
+      <anchorfile>cpp/utility/bitset/operator_ltltgtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_ulong</name>
+      <anchorfile>cpp/utility/bitset/to_ulong</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator^=</name>
+      <anchorfile>cpp/utility/bitset/operator_logic</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator~</name>
+      <anchorfile>cpp/utility/bitset/operator_logic</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>to_ullong</name>
+      <anchorfile>cpp/utility/bitset/to_ullong</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/utility/bitset/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flip</name>
+      <anchorfile>cpp/utility/bitset/flip</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bitset::reference</name>
+    <filename>cpp/utility/bitset/reference</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::FILE</name>
+    <filename>cpp/io/c</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::thread</name>
+    <filename>cpp/thread/thread</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>joinable</name>
+      <anchorfile>cpp/thread/thread/joinable</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/thread/thread/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>native_handle</name>
+      <anchorfile>cpp/thread/thread/native_handle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~thread</name>
+      <anchorfile>cpp/thread/thread/~thread</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/thread/thread/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hardware_concurrency</name>
+      <anchorfile>cpp/thread/thread/hardware_concurrency</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::thread::id</class>
+    <member kind="function">
+      <type>T</type>
+      <name>thread</name>
+      <anchorfile>cpp/thread/thread/thread</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>join</name>
+      <anchorfile>cpp/thread/thread/join</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>detach</name>
+      <anchorfile>cpp/thread/thread/detach</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_id</name>
+      <anchorfile>cpp/thread/thread/get_id</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::thread::id</name>
+    <filename>cpp/thread/thread/id</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/thread/thread/id/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;=</name>
+      <anchorfile>cpp/thread/thread/id/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;=</name>
+      <anchorfile>cpp/thread/thread/id/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;</name>
+      <anchorfile>cpp/thread/thread/id/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/thread/thread/id/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/thread/thread/id/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>id</name>
+      <anchorfile>cpp/thread/thread/id/id</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;</name>
+      <anchorfile>cpp/thread/thread/id/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::future_error</name>
+    <filename>cpp/thread/future_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>code</name>
+      <anchorfile>cpp/thread/future_error/code</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>future_error</name>
+      <anchorfile>cpp/thread/future_error/future_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::time_base</name>
+    <filename>cpp/locale/time_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::alignment_of</name>
+    <filename>cpp/types/alignment_of</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_put</name>
+    <filename>cpp/locale/time_put</filename>
+    <class kind="class">std::time_put::char_type</class>
+    <class kind="class">std::time_put::iter_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_put</name>
+      <anchorfile>cpp/locale/time_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~time_put</name>
+      <anchorfile>cpp/locale/time_put/~time_put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/locale/time_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>time_put</name>
+      <anchorfile>cpp/locale/time_put/time_put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::time_put::char_type</name>
+    <filename>cpp/locale/time_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_put::iter_type</name>
+    <filename>cpp/locale/time_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::bit_or</name>
+    <filename>cpp/utility/functional/bit_or</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/bit_or</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::pointer_traits</name>
+    <filename>cpp/memory/pointer_traits</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pointer_to</name>
+      <anchorfile>cpp/memory/pointer_traits/pointer_to</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_string</name>
+    <filename>cpp/string/basic_string</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/string/basic_string/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shrink_to_fit</name>
+      <anchorfile>cpp/string/basic_string/shrink_to_fit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rfind</name>
+      <anchorfile>cpp/string/basic_string/rfind</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/string/basic_string/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>append</name>
+      <anchorfile>cpp/string/basic_string/append</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/string/basic_string/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/string/basic_string/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/string/basic_string/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/string/basic_string/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/string/basic_string/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy</name>
+      <anchorfile>cpp/string/basic_string/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/string/basic_string/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>replace</name>
+      <anchorfile>cpp/string/basic_string/replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/string/basic_string/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/string/basic_string/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/string/basic_string/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/string/basic_string/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/string/basic_string/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/string/basic_string/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>capacity</name>
+      <anchorfile>cpp/string/basic_string/capacity</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>c_str</name>
+      <anchorfile>cpp/string/basic_string/c_str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/string/basic_string/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>substr</name>
+      <anchorfile>cpp/string/basic_string/substr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/string/basic_string/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/string/basic_string/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/string/basic_string/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/string/basic_string/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/string/basic_string/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_string</name>
+      <anchorfile>cpp/string/basic_string/basic_string</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::priority_queue</name>
+    <filename>cpp/container/priority_queue</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/priority_queue/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/priority_queue/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>priority_queue</name>
+      <anchorfile>cpp/container/priority_queue/priority_queue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/priority_queue/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/priority_queue/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop</name>
+      <anchorfile>cpp/container/priority_queue/pop</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/priority_queue/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push</name>
+      <anchorfile>cpp/container/priority_queue/push</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>top</name>
+      <anchorfile>cpp/container/priority_queue/top</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~priority_queue</name>
+      <anchorfile>cpp/container/priority_queue/~priority_queue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::exa</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wostringstream</name>
+    <filename>cpp/io/basic_ostringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_ostringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wostringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wostringstream</name>
+      <anchorfile>cpp/io/basic_ostringstream/basic_ostringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wostringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ostringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wostringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wostringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wostringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wostringstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_default_constructible</name>
+    <filename>cpp/types/is_default_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::cregex_iterator</name>
+    <filename>cpp/regex/regex_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cregex_iterator</name>
+      <anchorfile>cpp/regex/regex_iterator/regex_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wstring</name>
+    <filename>cpp/string/basic_string</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/string/basic_string/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shrink_to_fit</name>
+      <anchorfile>cpp/string/basic_string/shrink_to_fit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rfind</name>
+      <anchorfile>cpp/string/basic_string/rfind</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/string/basic_string/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>append</name>
+      <anchorfile>cpp/string/basic_string/append</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/string/basic_string/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/string/basic_string/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/string/basic_string/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/string/basic_string/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/string/basic_string/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy</name>
+      <anchorfile>cpp/string/basic_string/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/string/basic_string/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>replace</name>
+      <anchorfile>cpp/string/basic_string/replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wstring</name>
+      <anchorfile>cpp/string/basic_string/basic_string</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/string/basic_string/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/string/basic_string/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/string/basic_string/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/string/basic_string/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/string/basic_string/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>capacity</name>
+      <anchorfile>cpp/string/basic_string/capacity</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>c_str</name>
+      <anchorfile>cpp/string/basic_string/c_str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/string/basic_string/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>substr</name>
+      <anchorfile>cpp/string/basic_string/substr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/string/basic_string/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/string/basic_string/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/string/basic_string/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/string/basic_string/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/string/basic_string/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/string/basic_string/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::remove_all_extents</name>
+    <filename>cpp/types/remove_all_extents</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::istrstream</name>
+    <filename>cpp/io/istrstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~istrstream</name>
+      <anchorfile>cpp/io/istrstream/~istrstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/istrstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istrstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istrstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>istrstream</name>
+      <anchorfile>cpp/io/istrstream/istrstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istrstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::istrstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::istrstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::istrstream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::unary_negate</name>
+    <filename>cpp/utility/functional/unary_negate</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/unary_negate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unary_negate</name>
+      <anchorfile>cpp/utility/functional/unary_negate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::unordered_multiset</name>
+    <filename>cpp/container/unordered_multiset</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>max_bucket_count</name>
+      <anchorfile>cpp/container/unordered_multiset/max_bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/unordered_multiset/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/unordered_multiset/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/unordered_multiset/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_count</name>
+      <anchorfile>cpp/container/unordered_multiset/bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_load_factor</name>
+      <anchorfile>cpp/container/unordered_multiset/max_load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/unordered_multiset/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/unordered_multiset/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unordered_multiset</name>
+      <anchorfile>cpp/container/unordered_multiset/unordered_multiset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end(int)</name>
+      <anchorfile>cpp/container/unordered_multiset/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_eq</name>
+      <anchorfile>cpp/container/unordered_multiset/key_eq</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hash_function</name>
+      <anchorfile>cpp/container/unordered_multiset/hash_function</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/unordered_multiset/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/unordered_multiset/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin(int)</name>
+      <anchorfile>cpp/container/unordered_multiset/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/unordered_multiset/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~unordered_multiset</name>
+      <anchorfile>cpp/container/unordered_multiset/~unordered_multiset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>load_factor</name>
+      <anchorfile>cpp/container/unordered_multiset/load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/unordered_multiset/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/unordered_multiset/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/unordered_multiset/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/container/unordered_multiset/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rehash</name>
+      <anchorfile>cpp/container/unordered_multiset/rehash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket</name>
+      <anchorfile>cpp/container/unordered_multiset/bucket</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/unordered_multiset/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/unordered_multiset/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/unordered_multiset/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/unordered_multiset/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend(int)</name>
+      <anchorfile>cpp/container/unordered_multiset/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/unordered_multiset/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/unordered_multiset/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin(int)</name>
+      <anchorfile>cpp/container/unordered_multiset/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/unordered_multiset/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_size</name>
+      <anchorfile>cpp/container/unordered_multiset/bucket_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostream</name>
+    <filename>cpp/io/basic_ostream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ostream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ostream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_ostream</name>
+      <anchorfile>cpp/io/basic_ostream/basic_ostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~basic_ostream</name>
+      <anchorfile>cpp/io/basic_ostream/~basic_ostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ostream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ostream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wsregex_iterator</name>
+    <filename>cpp/regex/regex_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>wsregex_iterator</name>
+      <anchorfile>cpp/regex/regex_iterator/regex_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_fast16_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_assignable</name>
+    <filename>cpp/types/is_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct</name>
+    <filename>cpp/locale/moneypunct</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_curr_symbol</name>
+      <anchorfile>cpp/locale/moneypunct/curr_symbol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_decimal_point</name>
+      <anchorfile>cpp/locale/moneypunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>thousands_sep</name>
+      <anchorfile>cpp/locale/moneypunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_pos_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>curr_symbol</name>
+      <anchorfile>cpp/locale/moneypunct/curr_symbol</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>positive_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>frac_digits</name>
+      <anchorfile>cpp/locale/moneypunct/frac_digits</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_negative_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~moneypunct</name>
+      <anchorfile>cpp/locale/moneypunct/~moneypunct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pos_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_thousands_sep</name>
+      <anchorfile>cpp/locale/moneypunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>neg_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>negative_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>grouping</name>
+      <anchorfile>cpp/locale/moneypunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_frac_digits</name>
+      <anchorfile>cpp/locale/moneypunct/frac_digits</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>decimal_point</name>
+      <anchorfile>cpp/locale/moneypunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_neg_format</name>
+      <anchorfile>cpp/locale/moneypunct/pos_format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::moneypunct::string_type</class>
+    <class kind="class">std::moneypunct::pattern</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_positive_sign</name>
+      <anchorfile>cpp/locale/moneypunct/positive_sign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::moneypunct::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>moneypunct</name>
+      <anchorfile>cpp/locale/moneypunct/moneypunct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_grouping</name>
+      <anchorfile>cpp/locale/moneypunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct::string_type</name>
+    <filename>cpp/locale/moneypunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct::pattern</name>
+    <filename>cpp/locale/money_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::moneypunct::char_type</name>
+    <filename>cpp/locale/moneypunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::type_index</name>
+    <filename>cpp/types/type_index</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/types/type_index/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hash_code</name>
+      <anchorfile>cpp/types/type_index/hash_code</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;=</name>
+      <anchorfile>cpp/types/type_index/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;</name>
+      <anchorfile>cpp/types/type_index/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/types/type_index/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;=</name>
+      <anchorfile>cpp/types/type_index/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>type_index</name>
+      <anchorfile>cpp/types/type_index/type_index</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>name</name>
+      <anchorfile>cpp/types/type_index/name</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;</name>
+      <anchorfile>cpp/types/type_index/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_standard_layout</name>
+    <filename>cpp/types/is_standard_layout</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::timed_mutex</name>
+    <filename>cpp/thread/timed_mutex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock</name>
+      <anchorfile>cpp/thread/timed_mutex/unlock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>native_handle</name>
+      <anchorfile>cpp/thread/timed_mutex/native_handle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_until</name>
+      <anchorfile>cpp/thread/timed_mutex/try_lock_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_for</name>
+      <anchorfile>cpp/thread/timed_mutex/try_lock_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/timed_mutex/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/timed_mutex/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>timed_mutex</name>
+      <anchorfile>cpp/thread/timed_mutex/timed_mutex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_exception</name>
+    <filename>cpp/error/bad_exception</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int_fast64_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::function</name>
+    <filename>cpp/utility/functional/function</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/utility/functional/function/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/utility/functional/function/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/utility/functional/function/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>target</name>
+      <anchorfile>cpp/utility/functional/function/target</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/function/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>target_type</name>
+      <anchorfile>cpp/utility/functional/function/target_type</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>function</name>
+      <anchorfile>cpp/utility/functional/function/function</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/utility/functional/function/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~function</name>
+      <anchorfile>cpp/utility/functional/function/~function</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_cast</name>
+    <filename>cpp/types/bad_cast</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_cast</name>
+      <anchorfile>cpp/types/bad_cast/bad_cast</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::error_condition</name>
+    <filename>cpp/error/error_condition</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>error_condition</name>
+      <anchorfile>cpp/error/error_condition/error_condition</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/error/error_condition/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/error/error_condition/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/error/error_condition/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>value</name>
+      <anchorfile>cpp/error/error_condition/value</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/error/error_condition/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>message</name>
+      <anchorfile>cpp/error/error_condition/message</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>category</name>
+      <anchorfile>cpp/error/error_condition/category</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::filebuf</name>
+    <filename>cpp/io/basic_filebuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_filebuf/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>filebuf</name>
+      <anchorfile>cpp/io/basic_filebuf/basic_filebuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_filebuf/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_filebuf/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~filebuf</name>
+      <anchorfile>cpp/io/basic_filebuf/~basic_filebuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_filebuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::int_least16_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::istreambuf_iterator</name>
+    <filename>cpp/iterator/istreambuf_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::u16string</name>
+    <filename>cpp/string/basic_string</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/string/basic_string/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shrink_to_fit</name>
+      <anchorfile>cpp/string/basic_string/shrink_to_fit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rfind</name>
+      <anchorfile>cpp/string/basic_string/rfind</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/string/basic_string/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>append</name>
+      <anchorfile>cpp/string/basic_string/append</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/string/basic_string/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/string/basic_string/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/string/basic_string/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/string/basic_string/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/string/basic_string/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy</name>
+      <anchorfile>cpp/string/basic_string/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/string/basic_string/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>replace</name>
+      <anchorfile>cpp/string/basic_string/replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/string/basic_string/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>substr</name>
+      <anchorfile>cpp/string/basic_string/substr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/string/basic_string/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/string/basic_string/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/string/basic_string/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/string/basic_string/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>capacity</name>
+      <anchorfile>cpp/string/basic_string/capacity</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>c_str</name>
+      <anchorfile>cpp/string/basic_string/c_str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/string/basic_string/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>u16string</name>
+      <anchorfile>cpp/string/basic_string/basic_string</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/string/basic_string/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/string/basic_string/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/string/basic_string/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/string/basic_string/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/string/basic_string/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/string/basic_string/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_error_condition_enum</name>
+    <filename>cpp/error/error_condition/is_error_condition_enum</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_nothrow_destructible</name>
+    <filename>cpp/types/is_destructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wiostream</name>
+    <filename>cpp/io/basic_iostream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wiostream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wiostream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wiostream</name>
+      <anchorfile>cpp/io/basic_iostream/basic_iostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wiostream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~wiostream</name>
+      <anchorfile>cpp/io/basic_iostream/~basic_iostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wiostream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wiostream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wiostream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::allocator_arg_t</name>
+    <filename>cpp/memory/allocator_arg_t</filename>
+  </compound>
+  <compound kind="namespace">
+    <name>std::rel_ops</name>
+    <filename></filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/utility/rel_ops/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;=</name>
+      <anchorfile>cpp/utility/rel_ops/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;=</name>
+      <anchorfile>cpp/utility/rel_ops/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;</name>
+      <anchorfile>cpp/utility/rel_ops/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_least32_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::collate</name>
+    <filename>cpp/locale/collate</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>hash</name>
+      <anchorfile>cpp/locale/collate/hash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_hash</name>
+      <anchorfile>cpp/locale/collate/hash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>collate</name>
+      <anchorfile>cpp/locale/collate/collate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::collate::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>~collate</name>
+      <anchorfile>cpp/locale/collate/~collate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_transform</name>
+      <anchorfile>cpp/locale/collate/transform</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>transform</name>
+      <anchorfile>cpp/locale/collate/transform</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_compare</name>
+      <anchorfile>cpp/locale/collate/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::collate::string_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/locale/collate/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::collate::char_type</name>
+    <filename>cpp/locale/collate</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::collate::string_type</name>
+    <filename>cpp/locale/collate</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::remove_const</name>
+    <filename>cpp/types/remove_cv</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::u32string</name>
+    <filename>cpp/string/basic_string</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/string/basic_string/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shrink_to_fit</name>
+      <anchorfile>cpp/string/basic_string/shrink_to_fit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rfind</name>
+      <anchorfile>cpp/string/basic_string/rfind</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/string/basic_string/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>append</name>
+      <anchorfile>cpp/string/basic_string/append</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/string/basic_string/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/string/basic_string/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>u32string</name>
+      <anchorfile>cpp/string/basic_string/basic_string</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/string/basic_string/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/string/basic_string/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copy</name>
+      <anchorfile>cpp/string/basic_string/copy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/string/basic_string/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/string/basic_string/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>replace</name>
+      <anchorfile>cpp/string/basic_string/replace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/string/basic_string/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/string/basic_string/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/string/basic_string/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_first_of</name>
+      <anchorfile>cpp/string/basic_string/find_first_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/string/basic_string/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/string/basic_string/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/string/basic_string/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find_last_not_of</name>
+      <anchorfile>cpp/string/basic_string/find_last_not_of</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/string/basic_string/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>capacity</name>
+      <anchorfile>cpp/string/basic_string/capacity</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>c_str</name>
+      <anchorfile>cpp/string/basic_string/c_str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/string/basic_string/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/string/basic_string/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>substr</name>
+      <anchorfile>cpp/string/basic_string/substr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/string/basic_string/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/string/basic_string/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/string/basic_string/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/string/basic_string/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/string/basic_string/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/string/basic_string/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/string/basic_string/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/string/basic_string/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint_fast32_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_lvalue_reference</name>
+    <filename>cpp/types/is_lvalue_reference</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::complex</name>
+    <filename>cpp/numeric/complex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/numeric/complex/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>complex</name>
+      <anchorfile>cpp/numeric/complex/complex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-=</name>
+      <anchorfile>cpp/numeric/complex/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imag</name>
+      <anchorfile>cpp/numeric/complex/imag</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator+=</name>
+      <anchorfile>cpp/numeric/complex/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator/=</name>
+      <anchorfile>cpp/numeric/complex/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*=</name>
+      <anchorfile>cpp/numeric/complex/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>real</name>
+      <anchorfile>cpp/numeric/complex/real</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ofstream</name>
+    <filename>cpp/io/basic_ofstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ofstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_ofstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_ofstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ofstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_ofstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ofstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ofstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ofstream</name>
+      <anchorfile>cpp/io/basic_ofstream/basic_ofstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ofstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ofstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ofstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::insert_iterator</name>
+    <filename>cpp/iterator/insert_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_array_length</name>
+    <filename>cpp/memory/new/bad_array_length</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_array_length</name>
+      <anchorfile>cpp/memory/new/bad_array_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/memory/new/bad_alloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="namespace">
+    <name>std::this_thread</name>
+    <filename></filename>
+    <member kind="function">
+      <type>T</type>
+      <name>yield</name>
+      <anchorfile>cpp/thread/yield</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sleep_for</name>
+      <anchorfile>cpp/thread/sleep_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sleep_until</name>
+      <anchorfile>cpp/thread/sleep_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_id</name>
+      <anchorfile>cpp/thread/get_id</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_copyable</name>
+    <filename>cpp/types/is_trivially_copyable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istringstream</name>
+    <filename>cpp/io/basic_istringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_istringstream</name>
+      <anchorfile>cpp/io/basic_istringstream/basic_istringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_istringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_istringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_istringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_istringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_istringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_istringstream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ifstream</name>
+    <filename>cpp/io/basic_ifstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_ifstream</name>
+      <anchorfile>cpp/io/basic_ifstream/basic_ifstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_ifstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ifstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_ifstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ifstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_ifstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ifstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_ifstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ifstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ifstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_ifstream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::list</name>
+    <filename>cpp/container/list</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_front</name>
+      <anchorfile>cpp/container/list/pop_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push_back</name>
+      <anchorfile>cpp/container/list/push_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>splice</name>
+      <anchorfile>cpp/container/list/splice</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/list/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/list/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_front</name>
+      <anchorfile>cpp/container/list/emplace_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/list/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reverse</name>
+      <anchorfile>cpp/container/list/reverse</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/container/list/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/list/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>remove</name>
+      <anchorfile>cpp/container/list/remove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>list</name>
+      <anchorfile>cpp/container/list/list</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_back</name>
+      <anchorfile>cpp/container/list/emplace_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pop_back</name>
+      <anchorfile>cpp/container/list/pop_back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/list/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/container/list/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unique</name>
+      <anchorfile>cpp/container/list/unique</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/list/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>resize</name>
+      <anchorfile>cpp/container/list/resize</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>push_front</name>
+      <anchorfile>cpp/container/list/push_front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/list/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/list/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>assign</name>
+      <anchorfile>cpp/container/list/assign</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/list/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sort</name>
+      <anchorfile>cpp/container/list/sort</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~list</name>
+      <anchorfile>cpp/container/list/~list</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>merge</name>
+      <anchorfile>cpp/container/list/merge</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/list/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>remove_if</name>
+      <anchorfile>cpp/container/list/remove</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/list/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/list/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/list/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/list/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/list/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/list/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/list/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/list/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::minus</name>
+    <filename>cpp/utility/functional/minus</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/minus</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::map</name>
+    <filename>cpp/container/map</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/map/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/map/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/map/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/map/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/map/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/map/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_comp</name>
+      <anchorfile>cpp/container/map/key_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::map::value_compare</class>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/map/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/map/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/map/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>map</name>
+      <anchorfile>cpp/container/map/map</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/map/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/container/map/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>upper_bound</name>
+      <anchorfile>cpp/container/map/upper_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/map/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/map/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/map/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/map/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~map</name>
+      <anchorfile>cpp/container/map/~map</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>value_comp</name>
+      <anchorfile>cpp/container/map/value_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/map/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lower_bound</name>
+      <anchorfile>cpp/container/map/lower_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/map/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/map/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/map/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/map/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/map/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/map/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/map/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/container/map/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::map::value_compare</name>
+    <filename>cpp/container/map/value_compare</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::linear_congruential_engine</name>
+    <filename>cpp/numeric/random/linear_congruential_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>linear_congruential_engine</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/linear_congruential_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf16</name>
+    <filename>cpp/locale/codecvt_utf16</filename>
+    <class kind="class">std::codecvt_utf16::extern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unshift</name>
+      <anchorfile>cpp/locale/codecvt/unshift</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf16::state_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>encoding</name>
+      <anchorfile>cpp/locale/codecvt/encoding</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_out</name>
+      <anchorfile>cpp/locale/codecvt/out</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_max_length</name>
+      <anchorfile>cpp/locale/codecvt/max_length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_always_noconv</name>
+      <anchorfile>cpp/locale/codecvt/always_noconv</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in</name>
+      <anchorfile>cpp/locale/codecvt/in</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::codecvt_utf16::intern_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/locale/codecvt/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf16::extern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf16::state_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::codecvt_utf16::intern_type</name>
+    <filename>cpp/locale/codecvt</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::cmatch</name>
+    <filename>cpp/regex/match_results</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>format</name>
+      <anchorfile>cpp/regex/match_results/format</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/regex/match_results/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/regex/match_results/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>position</name>
+      <anchorfile>cpp/regex/match_results/position</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~cmatch</name>
+      <anchorfile>cpp/regex/match_results/~match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>prefix</name>
+      <anchorfile>cpp/regex/match_results/prefix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/match_results/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/regex/match_results/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>suffix</name>
+      <anchorfile>cpp/regex/match_results/suffix</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/regex/match_results/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/regex/match_results/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cmatch</name>
+      <anchorfile>cpp/regex/match_results/match_results</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ready</name>
+      <anchorfile>cpp/regex/match_results/ready</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/regex/match_results/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/regex/match_results/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/match_results/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/regex/match_results/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::defer_lock_t</name>
+    <filename>cpp/thread/lock_tag_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::exception</name>
+    <filename>cpp/error/exception</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~exception</name>
+      <anchorfile>cpp/error/exception/~exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/error/exception/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exception</name>
+      <anchorfile>cpp/error/exception/exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::front_insert_iterator</name>
+    <filename>cpp/iterator/front_insert_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::zetta</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::streambuf</name>
+    <filename>cpp/io/basic_streambuf</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>pptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>epptr</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eback</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setp</name>
+      <anchorfile>cpp/io/basic_streambuf/setp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputbackc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputbackc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/basic_streambuf/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sungetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sungetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbase</name>
+      <anchorfile>cpp/io/basic_streambuf/pptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetc</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubimbue</name>
+      <anchorfile>cpp/io/basic_streambuf/pubimbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>showmanyc</name>
+      <anchorfile>cpp/io/basic_streambuf/showmanyc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>snextc</name>
+      <anchorfile>cpp/io/basic_streambuf/snextc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>egptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow</name>
+      <anchorfile>cpp/io/basic_streambuf/underflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gbump</name>
+      <anchorfile>cpp/io/basic_streambuf/gbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>in_avail</name>
+      <anchorfile>cpp/io/basic_streambuf/in_avail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_streambuf/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbackfail</name>
+      <anchorfile>cpp/io/basic_streambuf/pbackfail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputc</name>
+      <anchorfile>cpp/io/basic_streambuf/sputc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xsgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>uflow</name>
+      <anchorfile>cpp/io/basic_streambuf/uflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>overflow</name>
+      <anchorfile>cpp/io/basic_streambuf/overflow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sputn</name>
+      <anchorfile>cpp/io/basic_streambuf/sputn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sgetn</name>
+      <anchorfile>cpp/io/basic_streambuf/sgetn</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sbumpc</name>
+      <anchorfile>cpp/io/basic_streambuf/sbumpc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~streambuf</name>
+      <anchorfile>cpp/io/basic_streambuf/~basic_streambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_streambuf/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pbump</name>
+      <anchorfile>cpp/io/basic_streambuf/pbump</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsetbuf</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsetbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubsync</name>
+      <anchorfile>cpp/io/basic_streambuf/pubsync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekoff</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekoff</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setg</name>
+      <anchorfile>cpp/io/basic_streambuf/setg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>streambuf</name>
+      <anchorfile>cpp/io/basic_streambuf/basic_streambuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gptr</name>
+      <anchorfile>cpp/io/basic_streambuf/gptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pubseekpos</name>
+      <anchorfile>cpp/io/basic_streambuf/pubseekpos</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="namespace">
+    <name>std::experimental</name>
+    <filename></filename>
+    <member kind="function">
+      <type>T</type>
+      <name>make_optional</name>
+      <anchorfile>cpp/experimental/optional/make_optional</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::experimental::optional</class>
+  </compound>
+  <compound kind="class">
+    <name>std::experimental::optional</name>
+    <filename>cpp/experimental/optional</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/experimental/optional/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/experimental/optional/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>optional</name>
+      <anchorfile>cpp/experimental/optional/optional</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~optional</name>
+      <anchorfile>cpp/experimental/optional/~optional</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/experimental/optional/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>value</name>
+      <anchorfile>cpp/experimental/optional/value</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>value_or</name>
+      <anchorfile>cpp/experimental/optional/value_or</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/experimental/optional/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/experimental/optional/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/experimental/optional/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::num_put</name>
+    <filename>cpp/locale/num_put</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>num_put</name>
+      <anchorfile>cpp/locale/num_put/num_put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::num_put::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>~num_put</name>
+      <anchorfile>cpp/locale/num_put/~num_put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_put</name>
+      <anchorfile>cpp/locale/num_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/locale/num_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::num_put::iter_type</class>
+  </compound>
+  <compound kind="class">
+    <name>std::num_put::char_type</name>
+    <filename>cpp/locale/num_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::num_put::iter_type</name>
+    <filename>cpp/locale/num_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::owner_less</name>
+    <filename>cpp/memory/owner_less</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/memory/owner_less</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::extent</name>
+    <filename>cpp/types/extent</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_optional_access</name>
+    <filename>cpp/utility/bad_optional_access</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_optional_access</name>
+      <anchorfile>cpp/utility/bad_optional_access</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::yotta</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wcregex_token_iterator</name>
+    <filename>cpp/regex/regex_token_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wcregex_token_iterator</name>
+      <anchorfile>cpp/regex/regex_token_iterator/regex_token_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::uint64_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::messages</name>
+    <filename>cpp/locale/messages</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_get</name>
+      <anchorfile>cpp/locale/messages/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_close</name>
+      <anchorfile>cpp/locale/messages/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::messages::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/locale/messages/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~messages</name>
+      <anchorfile>cpp/locale/messages/~messages</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_open</name>
+      <anchorfile>cpp/locale/messages/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>messages</name>
+      <anchorfile>cpp/locale/messages/messages</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/locale/messages/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::messages::string_type</class>
+    <class kind="class">std::messages::catalog</class>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/locale/messages/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::messages::char_type</name>
+    <filename>cpp/locale/messages</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::messages::string_type</name>
+    <filename>cpp/locale/messages</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::messages::catalog</name>
+    <filename>cpp/locale/messages_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::regex_token_iterator</name>
+    <filename>cpp/regex/regex_token_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>regex_token_iterator</name>
+      <anchorfile>cpp/regex/regex_token_iterator/regex_token_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::move_iterator</name>
+    <filename>cpp/iterator/move_iterator</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::messages_base</name>
+    <filename>cpp/locale/messages_base</filename>
+    <class kind="class">std::messages_base::catalog</class>
+  </compound>
+  <compound kind="class">
+    <name>std::messages_base::catalog</name>
+    <filename>cpp/locale/messages_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::istringstream</name>
+    <filename>cpp/io/basic_istringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_istringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>istringstream</name>
+      <anchorfile>cpp/io/basic_istringstream/basic_istringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_istringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::istringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::istringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::istringstream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::giga</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::integer_sequence</name>
+    <filename>cpp/utility/integer_sequence</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::has_virtual_destructor</name>
+    <filename>cpp/types/has_virtual_destructor</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::max_align_t</name>
+    <filename>cpp/types/max_align_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::remove_volatile</name>
+    <filename>cpp/types/remove_cv</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::underlying_type</name>
+    <filename>cpp/types/underlying_type</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::hecto</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_member_object_pointer</name>
+    <filename>cpp/types/is_member_object_pointer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::exception_ptr</name>
+    <filename>cpp/error/exception_ptr</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::nested_exception</name>
+    <filename>cpp/error/nested_exception</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/error/nested_exception/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~nested_exception</name>
+      <anchorfile>cpp/error/nested_exception/~nested_exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rethrow_nested</name>
+      <anchorfile>cpp/error/nested_exception/rethrow_nested</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>nested_exception</name>
+      <anchorfile>cpp/error/nested_exception/nested_exception</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>nested_ptr</name>
+      <anchorfile>cpp/error/nested_exception/nested_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::random_access_iterator_tag</name>
+    <filename>cpp/iterator/iterator_tags</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ctype</name>
+    <filename>cpp/locale/ctype</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>do_toupper</name>
+      <anchorfile>cpp/locale/ctype/toupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>toupper</name>
+      <anchorfile>cpp/locale/ctype/toupper</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>scan_is</name>
+      <anchorfile>cpp/locale/ctype/scan_is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/locale/ctype/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~ctype</name>
+      <anchorfile>cpp/locale/ctype/~ctype</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_narrow</name>
+      <anchorfile>cpp/locale/ctype/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/locale/ctype/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is</name>
+      <anchorfile>cpp/locale/ctype/is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_scan_is</name>
+      <anchorfile>cpp/locale/ctype/scan_is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tolower</name>
+      <anchorfile>cpp/locale/ctype/tolower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_is</name>
+      <anchorfile>cpp/locale/ctype/is</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_tolower</name>
+      <anchorfile>cpp/locale/ctype/tolower</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ctype::mask</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_widen</name>
+      <anchorfile>cpp/locale/ctype/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ctype</name>
+      <anchorfile>cpp/locale/ctype/ctype</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ctype::mask</name>
+    <filename>cpp/locale/ctype_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::time_t</name>
+    <filename>cpp/chrono/c/time_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::knuth_b</name>
+    <filename>cpp/numeric/random/shuffle_order_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>knuth_b</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/shuffle_order_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>base</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/base</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/shuffle_order_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::auto_ptr</name>
+    <filename>cpp/memory/auto_ptr</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>release</name>
+      <anchorfile>cpp/memory/auto_ptr/release</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/memory/auto_ptr/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator auto_ptr&lt;Y&gt;</name>
+      <anchorfile>cpp/memory/auto_ptr/operator_auto_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/memory/auto_ptr/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/memory/auto_ptr/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/memory/auto_ptr/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>auto_ptr</name>
+      <anchorfile>cpp/memory/auto_ptr/auto_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~auto_ptr</name>
+      <anchorfile>cpp/memory/auto_ptr/~auto_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/memory/auto_ptr/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::minstd_rand0</name>
+    <filename>cpp/numeric/random/linear_congruential_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>minstd_rand0</name>
+      <anchorfile>cpp/numeric/random/linear_congruential_engine/linear_congruential_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::sregex_token_iterator</name>
+    <filename>cpp/regex/regex_token_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sregex_token_iterator</name>
+      <anchorfile>cpp/regex/regex_token_iterator/regex_token_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator==</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_cmp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator-&gt;</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++(int)</name>
+      <anchorfile>cpp/regex/regex_token_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::logical_not</name>
+    <filename>cpp/utility/functional/logical_not</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/utility/functional/logical_not</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::fpos_t</name>
+    <filename>cpp/io/c</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::istream</name>
+    <filename>cpp/io/basic_istream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~istream</name>
+      <anchorfile>cpp/io/basic_istream/~basic_istream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>istream</name>
+      <anchorfile>cpp/io/basic_istream/basic_istream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::istream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::istream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::istream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::istream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::seed_seq</name>
+    <filename>cpp/numeric/random/seed_seq</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>generate</name>
+      <anchorfile>cpp/numeric/random/seed_seq/generate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/seed_seq/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/numeric/random/seed_seq/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed_seq</name>
+      <anchorfile>cpp/numeric/random/seed_seq/seed_seq</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::default_delete</name>
+    <filename>cpp/memory/default_delete</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>default_delete</name>
+      <anchorfile>cpp/memory/default_delete</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/memory/default_delete</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::femto</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::clock_t</name>
+    <filename>cpp/chrono/c/clock_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::true_type</name>
+    <filename>cpp/types/integral_constant</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::mbstate_t</name>
+    <filename>cpp/string/multibyte/mbstate_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ostrstream</name>
+    <filename>cpp/io/ostrstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/ostrstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostrstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>pcount</name>
+      <anchorfile>cpp/io/ostrstream/pcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ostrstream</name>
+      <anchorfile>cpp/io/ostrstream/ostrstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostrstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>freeze</name>
+      <anchorfile>cpp/io/ostrstream/freeze</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~ostrstream</name>
+      <anchorfile>cpp/io/ostrstream/~ostrstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ostrstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostrstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ostrstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ostrstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::gamma_distribution</name>
+    <filename>cpp/numeric/random/gamma_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>gamma_distribution</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/gamma_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>alpha</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>beta</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/gamma_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::bad_weak_ptr</name>
+    <filename>cpp/memory/bad_weak_ptr</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>bad_weak_ptr</name>
+      <anchorfile>cpp/memory/bad_weak_ptr/bad_weak_ptr</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::output_iterator_tag</name>
+    <filename>cpp/iterator/iterator_tags</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::micro</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivial</name>
+    <filename>cpp/types/is_trivial</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::packaged_task</name>
+    <filename>cpp/thread/packaged_task</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/thread/packaged_task/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/thread/packaged_task/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/thread/packaged_task/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>packaged_task</name>
+      <anchorfile>cpp/thread/packaged_task/packaged_task</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>make_ready_at_thread_exit</name>
+      <anchorfile>cpp/thread/packaged_task/make_ready_at_thread_exit</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/thread/packaged_task/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_future</name>
+      <anchorfile>cpp/thread/packaged_task/get_future</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>valid</name>
+      <anchorfile>cpp/thread/packaged_task/valid</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~packaged_task</name>
+      <anchorfile>cpp/thread/packaged_task/~packaged_task</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::unordered_set</name>
+    <filename>cpp/container/unordered_set</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>max_bucket_count</name>
+      <anchorfile>cpp/container/unordered_set/max_bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/unordered_set/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/unordered_set/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/unordered_set/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_count</name>
+      <anchorfile>cpp/container/unordered_set/bucket_count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_load_factor</name>
+      <anchorfile>cpp/container/unordered_set/max_load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/unordered_set/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/unordered_set/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end(int)</name>
+      <anchorfile>cpp/container/unordered_set/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~unordered_set</name>
+      <anchorfile>cpp/container/unordered_set/~unordered_set</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_eq</name>
+      <anchorfile>cpp/container/unordered_set/key_eq</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>hash_function</name>
+      <anchorfile>cpp/container/unordered_set/hash_function</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/unordered_set/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/unordered_set/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/unordered_set/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin(int)</name>
+      <anchorfile>cpp/container/unordered_set/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/unordered_set/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin(int)</name>
+      <anchorfile>cpp/container/unordered_set/begin2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>load_factor</name>
+      <anchorfile>cpp/container/unordered_set/load_factor</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/unordered_set/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/unordered_set/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/unordered_set/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reserve</name>
+      <anchorfile>cpp/container/unordered_set/reserve</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rehash</name>
+      <anchorfile>cpp/container/unordered_set/rehash</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket</name>
+      <anchorfile>cpp/container/unordered_set/bucket</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/unordered_set/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/unordered_set/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/unordered_set/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend(int)</name>
+      <anchorfile>cpp/container/unordered_set/end2</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/unordered_set/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unordered_set</name>
+      <anchorfile>cpp/container/unordered_set/unordered_set</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/unordered_set/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/unordered_set/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bucket_size</name>
+      <anchorfile>cpp/container/unordered_set/bucket_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_volatile</name>
+    <filename>cpp/types/is_volatile</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wfstream</name>
+    <filename>cpp/io/basic_fstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_fstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wfstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wfstream</name>
+      <anchorfile>cpp/io/basic_fstream/basic_fstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wfstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_fstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wfstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_fstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_fstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wfstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wfstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wfstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::multimap</name>
+    <filename>cpp/container/multimap</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>multimap</name>
+      <anchorfile>cpp/container/multimap/multimap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/multimap/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>erase</name>
+      <anchorfile>cpp/container/multimap/erase</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>insert</name>
+      <anchorfile>cpp/container/multimap/insert</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/multimap/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/multimap/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~multimap</name>
+      <anchorfile>cpp/container/multimap/~multimap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace_hint</name>
+      <anchorfile>cpp/container/multimap/emplace_hint</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>key_comp</name>
+      <anchorfile>cpp/container/multimap/key_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::multimap::value_compare</class>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/multimap/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>count</name>
+      <anchorfile>cpp/container/multimap/count</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>find</name>
+      <anchorfile>cpp/container/multimap/find</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/multimap/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>upper_bound</name>
+      <anchorfile>cpp/container/multimap/upper_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/multimap/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/multimap/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/multimap/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/container/multimap/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>value_comp</name>
+      <anchorfile>cpp/container/multimap/value_comp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/multimap/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lower_bound</name>
+      <anchorfile>cpp/container/multimap/lower_bound</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/multimap/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/multimap/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/multimap/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get_allocator</name>
+      <anchorfile>cpp/container/multimap/get_allocator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/container/multimap/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>equal_range</name>
+      <anchorfile>cpp/container/multimap/equal_range</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>emplace</name>
+      <anchorfile>cpp/container/multimap/emplace</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::multimap::value_compare</name>
+    <filename>cpp/container/multimap/value_compare</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::atomic_flag</name>
+    <filename>cpp/atomic/atomic_flag</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/atomic/atomic_flag/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/atomic/atomic_flag/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>atomic_flag</name>
+      <anchorfile>cpp/atomic/atomic_flag/atomic_flag</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>test_and_set</name>
+      <anchorfile>cpp/atomic/atomic_flag/test_and_set</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::numpunct_byname</name>
+    <filename>cpp/locale/numpunct_byname</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>grouping</name>
+      <anchorfile>cpp/locale/numpunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_decimal_point</name>
+      <anchorfile>cpp/locale/numpunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>thousands_sep</name>
+      <anchorfile>cpp/locale/numpunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>falsename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_falsename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::numpunct_byname::string_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>numpunct_byname</name>
+      <anchorfile>cpp/locale/numpunct_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>truename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::numpunct_byname::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_truename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_grouping</name>
+      <anchorfile>cpp/locale/numpunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>decimal_point</name>
+      <anchorfile>cpp/locale/numpunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_thousands_sep</name>
+      <anchorfile>cpp/locale/numpunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~numpunct_byname</name>
+      <anchorfile>cpp/locale/numpunct_byname</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::numpunct_byname::string_type</name>
+    <filename>cpp/locale/numpunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::numpunct_byname::char_type</name>
+    <filename>cpp/locale/numpunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::binomial_distribution</name>
+    <filename>cpp/numeric/random/binomial_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>t</name>
+      <anchorfile>cpp/numeric/random/binomial_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>binomial_distribution</name>
+      <anchorfile>cpp/numeric/random/binomial_distribution/binomial_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/binomial_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/binomial_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>p</name>
+      <anchorfile>cpp/numeric/random/binomial_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/binomial_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/binomial_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_iostream</name>
+    <filename>cpp/io/basic_iostream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~basic_iostream</name>
+      <anchorfile>cpp/io/basic_iostream/~basic_iostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_iostream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_iostream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>basic_iostream</name>
+      <anchorfile>cpp/io/basic_iostream/basic_iostream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::basic_iostream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_iostream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_iostream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::basic_iostream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wofstream</name>
+    <filename>cpp/io/basic_ofstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wofstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_ofstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wofstream</name>
+      <anchorfile>cpp/io/basic_ofstream/basic_ofstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_ofstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wofstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_ofstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ofstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wofstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wofstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wofstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wofstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_ostream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::fpos</name>
+    <filename>cpp/io/fpos</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>state</name>
+      <anchorfile>cpp/io/fpos/state</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::underflow_error</name>
+    <filename>cpp/error/underflow_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>underflow_error</name>
+      <anchorfile>cpp/error/underflow_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::cauchy_distribution</name>
+    <filename>cpp/numeric/random/cauchy_distribution</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>reset</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/reset</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>a</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>param</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/param</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cauchy_distribution</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/cauchy_distribution</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>b</name>
+      <anchorfile>cpp/numeric/random/cauchy_distribution/params</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_trivially_copy_constructible</name>
+    <filename>cpp/types/is_copy_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::conditional</name>
+    <filename>cpp/types/conditional</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_pod</name>
+    <filename>cpp/types/is_pod</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int_least8_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::streamoff</name>
+    <filename>cpp/io/streamoff</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_move_assignable</name>
+    <filename>cpp/types/is_move_assignable</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::int_least32_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wstringstream</name>
+    <filename>cpp/io/basic_stringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>seekp</name>
+      <anchorfile>cpp/io/basic_ostream/seekp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_stringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellp</name>
+      <anchorfile>cpp/io/basic_ostream/tellp</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&lt;&lt;</name>
+      <anchorfile>cpp/io/basic_ostream/operator_ltlt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>write</name>
+      <anchorfile>cpp/io/basic_ostream/write</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wstringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flush</name>
+      <anchorfile>cpp/io/basic_ostream/flush</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_stringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wstringstream</name>
+      <anchorfile>cpp/io/basic_stringstream/basic_stringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/io/basic_ostream/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wstringstream::sentry</name>
+    <filename>cpp/io/basic_ostream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wstringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wstringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::subtract_with_carry_engine</name>
+    <filename>cpp/numeric/random/subtract_with_carry_engine</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>discard</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/discard</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>subtract_with_carry_engine</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seed</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/seed</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/subtract_with_carry_engine/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::regex_error</name>
+    <filename>cpp/regex/regex_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>code</name>
+      <anchorfile>cpp/regex/regex_error/code</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>regex_error</name>
+      <anchorfile>cpp/regex/regex_error/regex_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_constructible</name>
+    <filename>cpp/types/is_constructible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::piecewise_construct_t</name>
+    <filename>cpp/utility/piecewise_construct_t</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::mutex</name>
+    <filename>cpp/thread/mutex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>mutex</name>
+      <anchorfile>cpp/thread/mutex/mutex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock</name>
+      <anchorfile>cpp/thread/mutex/unlock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/mutex/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/mutex/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>native_handle</name>
+      <anchorfile>cpp/thread/mutex/native_handle</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::system_error</name>
+    <filename>cpp/error/system_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>code</name>
+      <anchorfile>cpp/error/system_error/code</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>system_error</name>
+      <anchorfile>cpp/error/system_error/system_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wistringstream</name>
+    <filename>cpp/io/basic_istringstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/io/basic_istringstream/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>wistringstream</name>
+      <anchorfile>cpp/io/basic_istringstream/basic_istringstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistringstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistringstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_istringstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::wistringstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wistringstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::wistringstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::wistringstream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_floating_point</name>
+    <filename>cpp/types/is_floating_point</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_not_equal</name>
+    <filename>cpp/numeric/ratio/ratio_not_equal</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ratio_multiply</name>
+    <filename>cpp/numeric/ratio/ratio_multiply</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::result_of</name>
+    <filename>cpp/types/result_of</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_fundamental</name>
+    <filename>cpp/types/is_fundamental</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ifstream</name>
+    <filename>cpp/io/basic_ifstream</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>setstate</name>
+      <anchorfile>cpp/io/basic_ios/setstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getloc</name>
+      <anchorfile>cpp/io/ios_base/getloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>precision</name>
+      <anchorfile>cpp/io/ios_base/precision</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>flags</name>
+      <anchorfile>cpp/io/ios_base/flags</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>widen</name>
+      <anchorfile>cpp/io/basic_ios/widen</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>readsome</name>
+      <anchorfile>cpp/io/basic_istream/readsome</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/io/basic_ios/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>setf</name>
+      <anchorfile>cpp/io/ios_base/setf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tie</name>
+      <anchorfile>cpp/io/basic_ios/tie</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>open</name>
+      <anchorfile>cpp/io/basic_ifstream/open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_ios/operator_bool</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>copyfmt</name>
+      <anchorfile>cpp/io/basic_ios/copyfmt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync_with_stdio</name>
+      <anchorfile>cpp/io/ios_base/sync_with_stdio</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>gcount</name>
+      <anchorfile>cpp/io/basic_istream/gcount</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>get</name>
+      <anchorfile>cpp/io/basic_istream/get</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>xalloc</name>
+      <anchorfile>cpp/io/ios_base/xalloc</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>read</name>
+      <anchorfile>cpp/io/basic_istream/read</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>getline</name>
+      <anchorfile>cpp/io/basic_istream/getline</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>exceptions</name>
+      <anchorfile>cpp/io/basic_ios/exceptions</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>iword</name>
+      <anchorfile>cpp/io/ios_base/iword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unget</name>
+      <anchorfile>cpp/io/basic_istream/unget</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ifstream::event_callback</class>
+    <member kind="function">
+      <type>T</type>
+      <name>narrow</name>
+      <anchorfile>cpp/io/basic_ios/narrow</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ifstream</name>
+      <anchorfile>cpp/io/basic_ifstream/basic_ifstream</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>good</name>
+      <anchorfile>cpp/io/basic_ios/good</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator!</name>
+      <anchorfile>cpp/io/basic_ios/operator!</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>close</name>
+      <anchorfile>cpp/io/basic_ifstream/close</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sync</name>
+      <anchorfile>cpp/io/basic_istream/sync</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>putback</name>
+      <anchorfile>cpp/io/basic_istream/putback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>ignore</name>
+      <anchorfile>cpp/io/basic_istream/ignore</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unsetf</name>
+      <anchorfile>cpp/io/ios_base/unsetf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>width</name>
+      <anchorfile>cpp/io/ios_base/width</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rdstate</name>
+      <anchorfile>cpp/io/basic_ios/rdstate</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>seekg</name>
+      <anchorfile>cpp/io/basic_istream/seekg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ifstream::failure</class>
+    <member kind="function">
+      <type>T</type>
+      <name>move</name>
+      <anchorfile>cpp/io/basic_ios/move</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>eof</name>
+      <anchorfile>cpp/io/basic_ios/eof</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>register_callback</name>
+      <anchorfile>cpp/io/ios_base/register_callback</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>pword</name>
+      <anchorfile>cpp/io/ios_base/pword</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/io/basic_ios/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>tellg</name>
+      <anchorfile>cpp/io/basic_istream/tellg</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator&gt;&gt;</name>
+      <anchorfile>cpp/io/basic_istream/operator_gtgt</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>set_rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/set_rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fail</name>
+      <anchorfile>cpp/io/basic_ios/fail</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>is_open</name>
+      <anchorfile>cpp/io/basic_ifstream/is_open</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>peek</name>
+      <anchorfile>cpp/io/basic_istream/peek</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/io/basic_ifstream/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::ifstream::sentry</class>
+    <member kind="function">
+      <type>T</type>
+      <name>rdbuf</name>
+      <anchorfile>cpp/io/basic_ios/rdbuf</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>imbue</name>
+      <anchorfile>cpp/io/basic_ios/imbue</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>bad</name>
+      <anchorfile>cpp/io/basic_ios/bad</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>clear</name>
+      <anchorfile>cpp/io/basic_ios/clear</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>init</name>
+      <anchorfile>cpp/io/basic_ios/init</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ifstream::event_callback</name>
+    <filename>cpp/io/ios_base/event_callback</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::ifstream::failure</name>
+    <filename>cpp/io/ios_base/failure</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>failure</name>
+      <anchorfile>cpp/io/ios_base/failure</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::ifstream::sentry</name>
+    <filename>cpp/io/basic_istream/sentry</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>~sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator bool</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sentry</name>
+      <anchorfile>cpp/io/basic_istream/sentry</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::u32streampos</name>
+    <filename>cpp/io/fpos</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>state</name>
+      <anchorfile>cpp/io/fpos/state</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::length_error</name>
+    <filename>cpp/error/length_error</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>length_error</name>
+      <anchorfile>cpp/error/length_error</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>what</name>
+      <anchorfile>cpp/error/exception/what</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::sub_match</name>
+    <filename>cpp/regex/sub_match</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator string_type</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>sub_match</name>
+      <anchorfile>cpp/regex/sub_match/sub_match</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>str</name>
+      <anchorfile>cpp/regex/sub_match/str</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>length</name>
+      <anchorfile>cpp/regex/sub_match/length</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>compare</name>
+      <anchorfile>cpp/regex/sub_match/compare</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::common_type</name>
+    <filename>cpp/types/common_type</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::shared_timed_mutex</name>
+    <filename>cpp/thread/shared_timed_mutex</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/unlock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>unlock_shared</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/unlock_shared</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_until</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/try_lock_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_for</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/try_lock_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_shared_until</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/try_lock_shared_until</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>shared_timed_mutex</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/shared_timed_mutex</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock_shared</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/lock_shared</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>lock</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/try_lock</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_shared</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/try_lock_shared</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>try_lock_shared_for</name>
+      <anchorfile>cpp/thread/shared_timed_mutex/try_lock_shared_for</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::array</name>
+    <filename>cpp/container/array</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>max_size</name>
+      <anchorfile>cpp/container/array/max_size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rbegin</name>
+      <anchorfile>cpp/container/array/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crend</name>
+      <anchorfile>cpp/container/array/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>crbegin</name>
+      <anchorfile>cpp/container/array/rbegin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>swap</name>
+      <anchorfile>cpp/container/array/swap</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>data</name>
+      <anchorfile>cpp/container/array/data</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>back</name>
+      <anchorfile>cpp/container/array/back</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>end</name>
+      <anchorfile>cpp/container/array/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>fill</name>
+      <anchorfile>cpp/container/array/fill</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>empty</name>
+      <anchorfile>cpp/container/array/empty</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cend</name>
+      <anchorfile>cpp/container/array/end</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>size</name>
+      <anchorfile>cpp/container/array/size</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>cbegin</name>
+      <anchorfile>cpp/container/array/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>rend</name>
+      <anchorfile>cpp/container/array/rend</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>front</name>
+      <anchorfile>cpp/container/array/front</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>at</name>
+      <anchorfile>cpp/container/array/at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator[]</name>
+      <anchorfile>cpp/container/array/operator_at</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>begin</name>
+      <anchorfile>cpp/container/array/begin</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::random_device</name>
+    <filename>cpp/numeric/random/random_device</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator()</name>
+      <anchorfile>cpp/numeric/random/random_device/operator()</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>random_device</name>
+      <anchorfile>cpp/numeric/random/random_device/random_device</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>entropy</name>
+      <anchorfile>cpp/numeric/random/random_device/entropy</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>min</name>
+      <anchorfile>cpp/numeric/random/random_device/min</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>max</name>
+      <anchorfile>cpp/numeric/random/random_device/max</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::default_random_engine</name>
+    <filename>cpp/numeric/random</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::raw_storage_iterator</name>
+    <filename>cpp/memory/raw_storage_iterator</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>operator=</name>
+      <anchorfile>cpp/memory/raw_storage_iterator/operator=</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>raw_storage_iterator</name>
+      <anchorfile>cpp/memory/raw_storage_iterator/raw_storage_iterator</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator*</name>
+      <anchorfile>cpp/memory/raw_storage_iterator/operator*</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>operator++</name>
+      <anchorfile>cpp/memory/raw_storage_iterator/operator_arith</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::is_convertible</name>
+    <filename>cpp/types/is_convertible</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::uint16_t</name>
+    <filename>cpp/types/integer</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_array</name>
+    <filename>cpp/types/is_array</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::mega</name>
+    <filename>cpp/numeric/ratio/ratio</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::numpunct</name>
+    <filename>cpp/locale/numpunct</filename>
+    <member kind="function">
+      <type>T</type>
+      <name>grouping</name>
+      <anchorfile>cpp/locale/numpunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_decimal_point</name>
+      <anchorfile>cpp/locale/numpunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>thousands_sep</name>
+      <anchorfile>cpp/locale/numpunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>numpunct</name>
+      <anchorfile>cpp/locale/numpunct/numpunct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_falsename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::numpunct::string_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_grouping</name>
+      <anchorfile>cpp/locale/numpunct/grouping</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>truename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::numpunct::char_type</class>
+    <member kind="function">
+      <type>T</type>
+      <name>falsename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_truename</name>
+      <anchorfile>cpp/locale/numpunct/truefalsename</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~numpunct</name>
+      <anchorfile>cpp/locale/numpunct/~numpunct</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>decimal_point</name>
+      <anchorfile>cpp/locale/numpunct/decimal_point</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>do_thousands_sep</name>
+      <anchorfile>cpp/locale/numpunct/thousands_sep</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+  </compound>
+  <compound kind="class">
+    <name>std::numpunct::string_type</name>
+    <filename>cpp/locale/numpunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::numpunct::char_type</name>
+    <filename>cpp/locale/numpunct</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_put</name>
+    <filename>cpp/locale/money_put</filename>
+    <class kind="class">std::money_put::char_type</class>
+    <class kind="class">std::money_put::pattern</class>
+    <member kind="function">
+      <type>T</type>
+      <name>do_put</name>
+      <anchorfile>cpp/locale/money_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>money_put</name>
+      <anchorfile>cpp/locale/money_put/money_put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>~money_put</name>
+      <anchorfile>cpp/locale/money_put/~money_put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <member kind="function">
+      <type>T</type>
+      <name>put</name>
+      <anchorfile>cpp/locale/money_put/put</anchorfile>
+      <anchor></anchor>
+      <arglist>(T... args)</arglist>
+    </member>
+    <class kind="class">std::money_put::string_type</class>
+    <class kind="class">std::money_put::iter_type</class>
+  </compound>
+  <compound kind="class">
+    <name>std::money_put::char_type</name>
+    <filename>cpp/locale/money_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_put::pattern</name>
+    <filename>cpp/locale/money_base</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_put::string_type</name>
+    <filename>cpp/locale/money_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::money_put::iter_type</name>
+    <filename>cpp/locale/money_put</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::new_handler</name>
+    <filename>cpp/memory/new/new_handler</filename>
+  </compound>
+  <compound kind="class">
+    <name>std::is_member_function_pointer</name>
+    <filename>cpp/types/is_member_function_pointer</filename>
+  </compound>
+  <compound kind="class">
+    <name>va_list</name>
+    <filename>cpp/utility/variadic/va_list</filename>
+  </compound>
+</tagfile>

From 5bbeec3ace4fb3fcf9d3b5aefc579dd896185edf Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Thu, 28 May 2020 00:22:16 +0000
Subject: [PATCH 155/290] updating DIRECTORY.md

---
 DIRECTORY.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index e99f32611..bbf405b7f 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -109,8 +109,13 @@
   * [Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/factorial.cpp)
   * [Fast Power](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fast_power.cpp)
   * [Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci.cpp)
+  * [Fibonacci Fast](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci_fast.cpp)
+  * [Fibonacci Large](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci_large.cpp)
   * [Gcd Iterative Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_iterative_euclidean.cpp)
+  * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_of_n_numbers.cpp)
   * [Gcd Recursive Euclidean](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/gcd_recursive_euclidean.cpp)
+  * [Large Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/large_factorial.cpp)
+  * [Large Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/large_number.h)
   * [Modular Inverse Fermat Little Theorem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/modular_inverse_fermat_little_theorem.cpp)
   * [Number Of Positive Divisors](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/number_of_positive_divisors.cpp)
   * [Power For Huge Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/power_for_huge_numbers.cpp)
@@ -137,12 +142,7 @@
   * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_hexadecimal.cpp)
   * [Decimal To Roman Numeral](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/decimal_to_roman_numeral.cpp)
   * [Fast Interger Input](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fast_interger_input.cpp)
-  * [Fibonacci Fast](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_fast.cpp)
-  * [Fibonacci Large](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/fibonacci_large.cpp)
-  * [Gcd Of N Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/gcd_of_n_numbers.cpp)
   * [Happy Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/happy_number.cpp)
-  * [Large Factorial](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/large_factorial.cpp)
-  * [Large Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/large_number.h)
   * [Matrix Exponentiation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/matrix_exponentiation.cpp)
   * [Palindrome Of Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/palindrome_of_number.cpp)
   * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)

From cc5ce16b5874ec33c3b3fb5fc48188d91bf4987c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 11:24:14 -0400
Subject: [PATCH 156/290] document happy numbers

---
 others/happy_number.cpp | 57 ++++++++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 23 deletions(-)

diff --git a/others/happy_number.cpp b/others/happy_number.cpp
index 7d25a1bbd..dacb2b8c4 100644
--- a/others/happy_number.cpp
+++ b/others/happy_number.cpp
@@ -1,28 +1,39 @@
-/* A happy number is a number whose sum of digits is calculated until the sum is a single digit,
-  and this sum turns out to be 1 */
-
-// Copyright 2019 TheAlgorithms contributors
+/**
+ * A [happy number](https://en.wikipedia.org/wiki/Happy_number) is a decimal
+ * number whose sum of digits is calculated until the sum is a single digit, and
+ * this sum turns out to be 1.
+ */
 
 #include <iostream>
 
-int main() {
-  int n, k, s = 0, d;
-  std::cout << "Enter a number:";
-  std::cin >> n;
-  s = 0;
-  k = n;
-  while (k > 9) {
-    while (k != 0) {
-      d = k % 10;
-      s += d;
-      k /= 10;
+/**
+ * Checks if a decimal number is a happy number
+ * \returns true if happy else false
+ */
+template <typename T>
+bool is_happy(T n) {
+    T s = 0;              // stores sum of digits
+    while (n > 9) {       // while number is > 9, there are more than 1 digit
+        while (n != 0) {  // get digit
+            T d = n % 10;
+            s += d;
+            n /= 10;
+        }
+        n = s;
+        s = 0;
     }
-    k = s;
-    s = 0;
-  }
-  if (k == 1)
-    std::cout << n << " is a happy number" << std::endl;
-  else
-    std::cout << n << " is not a happy number" << std::endl;
-  return 0;
+    return (n == 1) ? true : false;  // true if k == 1
+}
+
+/** Main function */
+int main() {
+    int n;
+    std::cout << "Enter a number:";
+    std::cin >> n;
+
+    if (is_happy(n))
+        std::cout << n << " is a happy number" << std::endl;
+    else
+        std::cout << n << " is not a happy number" << std::endl;
+    return 0;
 }

From 84d33ba5d9dddb630b372bccf83eb0804e5513a0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 11:24:22 -0400
Subject: [PATCH 157/290] document matrix exponentiation

---
 others/matrix_exponentiation.cpp | 80 +++++++++++++++++++++++---------
 1 file changed, 57 insertions(+), 23 deletions(-)

diff --git a/others/matrix_exponentiation.cpp b/others/matrix_exponentiation.cpp
index f9b4997e9..d44d22593 100644
--- a/others/matrix_exponentiation.cpp
+++ b/others/matrix_exponentiation.cpp
@@ -1,20 +1,24 @@
-/*
-Matrix Exponentiation.
+/**
+@file
+@brief Matrix Exponentiation.
+
 The problem can be solved with DP but constraints are high.
-ai = bi (for i <= k)
-ai = c1*ai-1 + c2*ai-2 + ... + ck*ai-k (for i > k)
-Taking the example of Fibonacci series, K=2
-b1 = 1, b2=1
-c1 = 1, c2=1
-a = 0 1 1 2 ....
-This way you can find the 10^18 fibonacci number%MOD.
+<br/>\f$a_i = b_i\f$ (for \f$i <= k\f$)
+<br/>\f$a_i = c_1 a_{i-1} + c_2 a_{i-2} + ... + c_k a_{i-k}\f$ (for \f$i > k\f$)
+<br/>Taking the example of Fibonacci series, \f$k=2\f$
+<br/>\f$b_1 = 1,\; b_2=1\f$
+<br/>\f$c_1 = 1,\; c_2=1\f$
+<br/>\f$a = \begin{bmatrix}0& 1& 1& 2& \ldots\end{bmatrix}\f$
+<br/>This way you can find the \f$10^{18}\f$ fibonacci number%MOD.
 I have given a general way to use it. The program takes the input of B and C
 matrix.
+
 Steps for Matrix Expo
 1. Create vector F1 : which is the copy of B.
 2. Create transpose matrix (Learn more about it on the internet)
-3. Perform T^(n-1) [transpose matrix to the power n-1]
-4. Multiply with F to get the last matrix of size (1xk).
+3. Perform \f$T^{n-1}\f$ [transpose matrix to the power n-1]
+4. Multiply with F to get the last matrix of size (1\f$\times\f$k).
+
 The first element of this matrix is the required result.
 */
 
@@ -25,16 +29,36 @@ using std::cin;
 using std::cout;
 using std::vector;
 
+/*! shorthand definition for `int64_t` */
 #define ll int64_t
-#define endl '\n'
+
+/*! shorthand definition for `std::endl` */
+#define endl std::endl
+
+/*! shorthand definition for `int64_t` */
 #define pb push_back
 #define MOD 1000000007
-ll ab(ll x) { return x > 0LL ? x : -x; }
+
+/** returns absolute value */
+inline ll ab(ll x) { return x > 0LL ? x : -x; }
+
+/** global variable k
+ * @todo @stepfencurryxiao add documetnation
+ */
 ll k;
+
+/** global vector variables
+ * @todo @stepfencurryxiao add documetnation
+ */
 vector<ll> a, b, c;
 
-// To multiply 2 matrix
-vector<vector<ll>> multiply(vector<vector<ll>> A, vector<vector<ll>> B) {
+/** To multiply 2 matrices
+ * \param [in] A matrix 1 of size (m\f$\times\f$n)
+ * \param [in] B \p matrix 2 of size (p\f$\times\f$q)\n\note \f$p=n\f$
+ * \result matrix of dimension (m\f$\times\f$q)
+ */
+vector<vector<ll>> multiply(const vector<vector<ll>> &A,
+                            const vector<vector<ll>> &B) {
     vector<vector<ll>> C(k + 1, vector<ll>(k + 1));
     for (ll i = 1; i <= k; i++) {
         for (ll j = 1; j <= k; j++) {
@@ -46,9 +70,15 @@ vector<vector<ll>> multiply(vector<vector<ll>> A, vector<vector<ll>> B) {
     return C;
 }
 
-// computing power of a matrix
-vector<vector<ll>> power(vector<vector<ll>> A, ll p) {
-    if (p == 1) return A;
+/** computing integer power of a matrix using recursive multiplication.
+ * @note A must be a square matrix for this algorithm.
+ * \param [in] A base matrix
+ * \param [in] p exponent
+ * \return matrix of same dimension as A
+ */
+vector<vector<ll>> power(const vector<vector<ll>> &A, ll p) {
+    if (p == 1)
+        return A;
     if (p % 2 == 1) {
         return multiply(A, power(A, p - 1));
     } else {
@@ -57,10 +87,15 @@ vector<vector<ll>> power(vector<vector<ll>> A, ll p) {
     }
 }
 
-// main function
+/*! Wrapper for Fibonacci
+ * \param[in] n \f$n^\text{th}\f$ Fibonacci number
+ * \return \f$n^\text{th}\f$ Fibonacci number
+ */
 ll ans(ll n) {
-    if (n == 0) return 0;
-    if (n <= k) return b[n - 1];
+    if (n == 0)
+        return 0;
+    if (n <= k)
+        return b[n - 1];
     // F1
     vector<ll> F1(k + 1);
     for (ll i = 1; i <= k; i++) F1[i] = b[i - 1];
@@ -90,8 +125,7 @@ ll ans(ll n) {
     return res;
 }
 
-// 1 1 2 3 5
-
+/** Main function */
 int main() {
     cin.tie(0);
     cout.tie(0);

From 0c8515657303d2cdafc33dafed35dd0cda9f9d7d Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 11:24:36 -0400
Subject: [PATCH 158/290] document number palindrome

---
 others/palindrome_of_number.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index 621b09ab6..66401ff96 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -1,3 +1,10 @@
+/**
+ * @file
+ * @brief Check if a number is
+ * [palindrome](https://en.wikipedia.org/wiki/Palindrome) or not.
+ *
+ * This program cheats by using the STL library's std::reverse function.
+ */
 #include <algorithm>
 #include <iostream>
 
@@ -8,17 +15,18 @@
 #include <cstring>
 #endif
 
+/** Main function */
 int main() {
     int num;
     std::cout << "Enter number = ";
     std::cin >> num;
 
-    std::string s1 = std::to_string(num);
+    std::string s1 = std::to_string(num);  // convert number to string
     std::string s2 = s1;
 
-    reverse(s1.begin(), s1.end());
+    std::reverse(s1.begin(), s1.end());  // reverse the string
 
-    if (s1 == s2)
+    if (s1 == s2)  // check if reverse and original string are identical
         std::cout << "true";
     else
         std::cout << "false";

From 4206ac2a291cc96a4627c4fe8e61636de81eb8e2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 11:24:46 -0400
Subject: [PATCH 159/290] document paranthesis matching

---
 others/paranthesis_matching.cpp | 131 ++++++++++++++++----------------
 1 file changed, 65 insertions(+), 66 deletions(-)

diff --git a/others/paranthesis_matching.cpp b/others/paranthesis_matching.cpp
index d2bb4d39c..ef5da6e47 100644
--- a/others/paranthesis_matching.cpp
+++ b/others/paranthesis_matching.cpp
@@ -1,76 +1,75 @@
+/**
+ * @file
+ * @brief Perform paranthesis matching. \note Do not know the application of
+ * this, however.
+ * @note Implementation is C-type and does not utilize the C++ constructs
+ * @todo implement as a C++ class
+ */
 #include <iostream>
-#include <string>
-
-using namespace std;
+#ifdef _MSC_VER
+#include <string>  // Visual Studio C requires this include
+#else
+#include <cstring>
+#endif
 
+/** check number */
 #define MAX 100
 
-// -------------- stack --------------
-
+//! @{-------------- stack --------------
+//! global stack
 char stack[MAX];
+
+//! pointer to track stack index
 int top = -1;
 
-void push(char ch)
-{
-	stack[++top] = ch;
+//! push byte to stack variable
+void push(char ch) { stack[++top] = ch; }
+
+//! pop a byte out of stack variable
+char pop() { return stack[top--]; }
+
+//! @}-------------- end stack -----------
+
+/** return opening paranthesis corresponding to the close paranthesis
+ * @param[in] ch closed paranthesis character
+ */
+char opening(char ch) {
+    switch (ch) {
+        case '}':
+            return '{';
+        case ']':
+            return '[';
+        case ')':
+            return '(';
+        case '>':
+            return '<';
+    }
+    return '\0';
 }
 
-char pop()
-{
-	return stack[top--];
-}
-
-// -------------- end stack -----------
-
-char opening(char ch)
-{
-	switch (ch)
-	{
-	case '}':
-		return '{';
-	case ']':
-		return '[';
-	case ')':
-		return '(';
-	case '>':
-		return '<';
-	}
-}
-
-int main()
-{
-
-	string exp;
-	int valid = 1, i = 0;
-	cout << "Enter The Expression : ";
-	cin >> exp;
-
-	while (valid == 1 && i < exp.length())
-	{
-		if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<')
-		{
-			push(exp[i]);
-		}
-		else if (top >= 0 && stack[top] == opening(exp[i]))
-		{
-			pop();
-		}
-		else
-		{
-			valid = 0;
-		}
-		i++;
-	}
-
-	// makes sure the stack is empty after processsing (above)
-	if (valid == 1 && top == -1)
-	{
-		cout << "\nCorrect Expression";
-	}
-	else
-	{
-		cout << "\nWrong Expression";
-	}
-
-	return 0;
+int main() {
+    std::string exp;
+    int valid = 1, i = 0;
+    std::cout << "Enter The Expression : ";
+    std::cin >> exp;
+
+    while (valid == 1 && i < exp.length()) {
+        if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<') {
+            push(exp[i]);
+        } else if (top >= 0 && stack[top] == opening(exp[i])) {
+            pop();
+        } else {
+            valid = 0;
+        }
+        i++;
+    }
+
+    // makes sure the stack is empty after processsing (above)
+    if (valid == 1 && top == -1) {
+        std::cout << "\nCorrect Expression";
+    } else {
+        std::cout << "\nWrong Expression";
+    }
+
+    return 0;
 }

From 34c3ce9c5e6d6bd3cf5e4058f13d5d93be736216 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 11:24:55 -0400
Subject: [PATCH 160/290] document pascals triangle

---
 others/pascal_triangle.cpp | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/others/pascal_triangle.cpp b/others/pascal_triangle.cpp
index 063a6666a..4ea58f3f1 100644
--- a/others/pascal_triangle.cpp
+++ b/others/pascal_triangle.cpp
@@ -1,19 +1,38 @@
+/**
+ * @file
+ * @brief Pascal's triangle implementation
+ */
+#ifdef _MSC_VER
+#include <string>  // required for Visual C
+#else
 #include <cstring>
+#endif
+#include <iomanip>
 #include <iostream>
 
+/**
+ * Print the triangle
+ * \param [in] arr  2D-array containing Pascal numbers
+ * \param [in] n    depth of Pascal triangle to print
+ */
 void show_pascal(int **arr, int n) {
-    // pint Pascal's Triangle
     for (int i = 0; i < n; ++i) {
         for (int j = 0; j < n + i; ++j) {
             if (arr[i][j] == 0)
-                std::cout << " ";
+                std::cout << std::setw(4) << " ";
             else
-                std::cout << arr[i][j];
+                std::cout << std::setw(4) << arr[i][j];
         }
         std::cout << std::endl;
     }
 }
 
+/**
+ * Print the triangle
+ * \param [in,out] arr  array containing Pascal numbers
+ * \param [in] n    depth of Pascal triangle to print
+ * \result arr pointer returned
+ */
 int **pascal_triangle(int **arr, int n) {
     for (int i = 0; i < n; ++i) {
         for (int j = n - i - 1; j < n + i; ++j) {
@@ -27,6 +46,9 @@ int **pascal_triangle(int **arr, int n) {
     return arr;
 }
 
+/**
+ * main function
+ */
 int main() {
     int n = 0;
 

From 00c8c0bfdbc4b1c7b7beed29c281c45e66861731 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 12:55:06 -0400
Subject: [PATCH 161/290] document primality test

---
 others/primality_test.cpp | 60 +++++++++++++++++++++++----------------
 1 file changed, 35 insertions(+), 25 deletions(-)

diff --git a/others/primality_test.cpp b/others/primality_test.cpp
index ce8fc1706..faec6589c 100644
--- a/others/primality_test.cpp
+++ b/others/primality_test.cpp
@@ -1,32 +1,42 @@
+/**
+ * @file
+ * @brief [Primality test](https://en.wikipedia.org/wiki/Primality_test)
+ * implementation.
+ *
+ * A simple and efficient implementation of a function to test if a number is
+ * prime, based on the fact that
+ * > Every Prime number, except 2 and 3, are of the form \f$6k\pm1\f$ for
+ * > integer values of k.
+ * This gives a 3x speed improvement.
+ */
 #include <iostream>
-using namespace std;
 
-//A simple and efficient implementation of a function to test if a number is prime, based on the fact that
-//Every Prime number, except 2 and 3 are of the form 6*k+1 or 6*k-1 for integer values of k.
+/** Check if a number is prime
+ * \param[in] number number to check
+ * \returns true if prime else false
+ */
+bool IsPrime(int number) {
+    if (((!(number & 1)) && number != 2) || (number < 2) ||
+        (number % 3 == 0 && number != 3))
+        return false;
 
-bool IsPrime(int number)
-{
-	if (((!(number & 1)) && number != 2) || (number < 2) || (number % 3 == 0 && number != 3))
-		return false;
-
-	for (int k = 1; 36 * k * k - 12 * k < number; ++k)
-	{
-		if ((number % (6 * k + 1) == 0) || (number % (6 * k - 1) == 0))
-			return false;
-	}
-	return true;
+    for (int k = 1; 36 * k * k - 12 * k < number; ++k) {
+        if ((number % (6 * k + 1) == 0) || (number % (6 * k - 1) == 0))
+            return false;
+    }
+    return true;
 }
 
-int main()
-{
-	//Main Function
-	cout << "Enter the value of n to check if Prime\n";
-	int n;
-	cin >> n;
-	if (IsPrime(n))
-		cout << n << " is Prime" << endl;
-	else
-		cout << n << " is not Prime" << endl;
+/** main function */
+int main() {
+    // Main Function
+    std::cout << "Enter the value of n to check if Prime\n";
+    int n;
+    std::cin >> n;
+    if (IsPrime(n))
+        std::cout << n << " is Prime" << std::endl;
+    else
+        std::cout << n << " is not Prime" << std::endl;
 
-	return 0;
+    return 0;
 }

From be997d3da34367a6bc5f52fe719f6b72dd8a6cd4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 13:39:58 -0400
Subject: [PATCH 162/290] updated documentation - NOTE TESTS FAIL @yanglbme
 this algorithm does not give right answers

---
 others/smallest-circle.cpp | 190 ++++++++++++++++++++++++++-----------
 1 file changed, 132 insertions(+), 58 deletions(-)

diff --git a/others/smallest-circle.cpp b/others/smallest-circle.cpp
index 48437cd86..7eb913cd1 100644
--- a/others/smallest-circle.cpp
+++ b/others/smallest-circle.cpp
@@ -1,121 +1,195 @@
+/**
+ * @file
+ * @brief Get centre and radius of the
+ * [smallest circle](https://en.wikipedia.org/wiki/Smallest-circle_problem)
+ * that circumscribes given set of points.
+ *
+ * @see [other
+ * implementation](https://www.nayuki.io/page/smallest-enclosing-circle)
+ */
+#include <cmath>
 #include <iostream>
 #include <vector>
-#include <math.h>
 
-using namespace std;
+/** Define a point */
+struct Point {
+    double x, /**< abscissa */
+        y;    /**< ordinate */
 
-struct Point
-{
-    double x, y;
-    Point(double a = 0.0, double b = 0.0)
-    {
+    /** construct a point
+     * \param [in] a absicca (default = 0.0)
+     * \param [in] b ordinate (default = 0.0)
+     */
+    Point(double a = 0.0, double b = 0.0) {
         x = a;
         y = b;
     }
 };
 
-double LenghtLine(Point A, Point B)
-{
-    return sqrt(abs((B.x - A.x) * (B.x - A.x)) + abs((B.y - A.y) * (B.y - A.y)));
+/** Compute the Euclidian distance between two points \f$A\equiv(x_1,y_1)\f$ and
+ * \f$B\equiv(x_2,y_2)\f$ using the formula:
+ * \f[d=\sqrt{\left(x_1-x_2\right)^2+\left(y_1-y_2\right)^2}\f]
+ *
+ * \param [in] A point A
+ * \param [in] B point B
+ * \return ditance
+ */
+double LenghtLine(const Point &A, const Point &B) {
+    double dx = B.x - A.x;
+    double dy = B.y - A.y;
+    return std::sqrt((dx * dx) + (dy * dy));
 }
 
-double TriangleArea(Point A, Point B, Point C)
-{
+/**
+ * Compute the area of triangle formed by three points using [Heron's
+ * formula](https://en.wikipedia.org/wiki/Heron%27s_formula).
+ * If the lengths of the sides of the triangle are \f$a,\,b,\,c\f$ and
+ * \f$s=\displaystyle\frac{a+b+c}{2}\f$ is the semi-perimeter then the area is
+ * given by \f[A=\sqrt{s(s-a)(s-b)(s-c)}\f]
+ * \param [in] A vertex A
+ * \param [in] B vertex B
+ * \param [in] C vertex C
+ * \returns area of triangle
+ */
+double TriangleArea(const Point &A, const Point &B, const Point &C) {
     double a = LenghtLine(A, B);
     double b = LenghtLine(B, C);
     double c = LenghtLine(C, A);
     double p = (a + b + c) / 2;
-    return sqrt(p * (p - a) * (p - b) * (p - c));
+    return std::sqrt(p * (p - a) * (p - b) * (p - c));
 }
 
-bool PointInCircle(vector<Point> &P, Point Center, double R)
-{
-    for (size_t i = 0; i < P.size(); i++)
-    {
+/**
+ * Check if a set of points lie within given circle. This is true if the
+ * distance of all the points from the centre of the circle is less than the
+ * radius of the circle
+ * \param [in] P set of points to check
+ * \param [in] Center coordinates to centre of the circle
+ * \param [in] R radius of the circle
+ * \returns True if P lies on or within the circle
+ * \returns False if P lies outside the circle
+ */
+bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R) {
+    for (size_t i = 0; i < P.size(); i++) {
         if (LenghtLine(P[i], Center) > R)
             return false;
     }
     return true;
 }
 
-double circle(vector<Point> P)
-{
+/**
+ * Find the centre and radius of a circle enclosing a set of points.\n
+ * The function returns the radius of the circle and prints the coordinated of
+ * the centre of the circle.
+ * \param [in] P vector of points
+ * \returns radius of the circle
+ */
+double circle(const std::vector<Point> &P) {
     double minR = INT8_MAX;
     double R;
     Point C;
     Point minC;
-    for (size_t i = 0; i < P.size() - 2; i++)
-        for (size_t j = i + 1; j < P.size(); j++)
-            for (size_t k = j + 1; k < P.size(); k++)
-            {
-                C.x = -0.5 * ((P[i].y * (P[j].x * P[j].x + P[j].y * P[j].y - P[k].x * P[k].x - P[k].y * P[k].y) + P[j].y * (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y * P[i].y) + P[k].y * (P[i].x * P[i].x + P[i].y * P[i].y - P[j].x * P[j].x - P[j].y * P[j].y)) / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y - P[i].y) + P[k].x * (P[i].y - P[j].y)));
-                C.y = 0.5 * ((P[i].x * (P[j].x * P[j].x + P[j].y * P[j].y - P[k].x * P[k].x - P[k].y * P[k].y) + P[j].x * (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y * P[i].y) + P[k].x * (P[i].x * P[i].x + P[i].y * P[i].y - P[j].x * P[j].x - P[j].y * P[j].y)) / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y - P[i].y) + P[k].x * (P[i].y - P[j].y)));
-                R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k]) * LenghtLine(P[k], P[i])) / (4 * TriangleArea(P[i], P[j], P[k]));
-                if (!PointInCircle(P, C, R))
-                {
-                    continue;
+
+    /* This code is invalid and does not give correct result for TEST 3
+        // for each point in the list
+        for (size_t i = 0; i < P.size() - 2; i++)
+            // for every subsequent point in the list
+            for (size_t j = i + 1; j < P.size(); j++)
+                // for every subsequent point in the list
+                for (size_t k = j + 1; k < P.size(); k++) {
+                    // here, we now have picked three points from the given set
+       of
+                    // points that we can use
+                    // viz., P[i], P[j] and P[k]
+                    C.x = -0.5 * ((P[i].y * (P[j].x * P[j].x + P[j].y * P[j].y -
+                                             P[k].x * P[k].x - P[k].y * P[k].y)
+       + P[j].y * (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y
+       * P[i].y) + P[k].y * (P[i].x * P[i].x + P[i].y * P[i].y - P[j].x * P[j].x
+       - P[j].y * P[j].y)) / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y -
+       P[i].y) + P[k].x * (P[i].y - P[j].y))); C.y = 0.5 * ((P[i].x * (P[j].x *
+       P[j].x + P[j].y * P[j].y - P[k].x * P[k].x - P[k].y * P[k].y) + P[j].x *
+       (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y * P[i].y) +
+                                  P[k].x * (P[i].x * P[i].x + P[i].y * P[i].y -
+                                            P[j].x * P[j].x - P[j].y * P[j].y))
+       / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y - P[i].y) + P[k].x *
+       (P[i].y - P[j].y))); R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k])
+       * LenghtLine(P[k], P[i])) / (4 * TriangleArea(P[i], P[j], P[k])); if
+       (!PointInCircle(P, C, R)) { continue;
+                    }
+                    if (R <= minR) {
+                        minR = R;
+                        minC = C;
+                    }
                 }
-                if (R <= minR)
-                {
-                    minR = R;
-                    minC = C;
-                }
-            }
+    */
+
+    // for each point in the list
     for (size_t i = 0; i < P.size() - 1; i++)
-        for (size_t j = i + 1; j < P.size(); j++)
-        {
+        // for every subsequent point in the list
+        for (size_t j = i + 1; j < P.size(); j++) {
             C.x = (P[i].x + P[j].x) / 2;
             C.y = (P[i].y + P[j].y) / 2;
             R = LenghtLine(C, P[i]);
-            if (!PointInCircle(P, C, R))
-            {
+            if (!PointInCircle(P, C, R)) {
                 continue;
             }
-            if (R <= minR)
-            {
+            if (R <= minR) {
                 minR = R;
                 minC = C;
             }
         }
-    cout << minC.x << " " << minC.y << endl;
+    std::cout << minC.x << " " << minC.y << std::endl;
     return minR;
 }
 
-void test()
-{
-    vector<Point> Pv(5);
+/** Test case: result should be:
+ * \n Circle with
+ * \n radius 3.318493136080724
+ * \n centre at (3.0454545454545454 1.3181818181818181)
+ */
+void test() {
+    std::vector<Point> Pv(5);
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(1, 3));
     Pv.push_back(Point(4, 1));
     Pv.push_back(Point(5, 4));
     Pv.push_back(Point(3, -2));
-    cout << circle(Pv) << endl;
+    std::cout << circle(Pv) << std::endl;
 }
 
-void test2()
-{
-    vector<Point> Pv(4);
+/** Test case: result should be:
+ * \n Circle with
+ * \n radius 1.4142135623730951
+ * \n centre at (1.0 1.0)
+ */
+void test2() {
+    std::vector<Point> Pv(4);
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(0, 2));
     Pv.push_back(Point(2, 2));
     Pv.push_back(Point(2, 0));
-    cout << circle(Pv) << endl;
+    std::cout << circle(Pv) << std::endl;
 }
 
-void test3()
-{
-    vector<Point> Pv(3);
+/** Test case: result should be:
+ * \n Circle with
+ * \n radius 1.821078397711709
+ * \n centre at (2.142857142857143 1.7857142857142856)
+ */
+void test3() {
+    std::vector<Point> Pv(3);
     Pv.push_back(Point(0.5, 1));
     Pv.push_back(Point(3.5, 3));
     Pv.push_back(Point(2.5, 0));
-    cout << circle(Pv) << endl;
+    std::cout << circle(Pv) << std::endl;
 }
-int main()
-{
+
+/** Main program */
+int main() {
     test();
-    cout << endl;
+    std::cout << std::endl;
     test2();
-    cout << endl;
+    std::cout << std::endl;
     test3();
     return 0;
 }

From 9da5e0cecf583d35be1eae46638374bc4f12f9f9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:07:27 -0400
Subject: [PATCH 163/290] re-enable the commented algorithm

---
 others/smallest-circle.cpp | 81 +++++++++++++++++++++-----------------
 1 file changed, 44 insertions(+), 37 deletions(-)

diff --git a/others/smallest-circle.cpp b/others/smallest-circle.cpp
index 7eb913cd1..8f0231853 100644
--- a/others/smallest-circle.cpp
+++ b/others/smallest-circle.cpp
@@ -20,7 +20,7 @@ struct Point {
      * \param [in] a absicca (default = 0.0)
      * \param [in] b ordinate (default = 0.0)
      */
-    Point(double a = 0.0, double b = 0.0) {
+    Point(double a = 0.f, double b = 0.f) {
         x = a;
         y = b;
     }
@@ -90,38 +90,45 @@ double circle(const std::vector<Point> &P) {
     Point C;
     Point minC;
 
-    /* This code is invalid and does not give correct result for TEST 3
-        // for each point in the list
-        for (size_t i = 0; i < P.size() - 2; i++)
+    /* This code is invalid and does not give correct result for TEST 3 */
+    // for each point in the list
+    for (size_t i = 0; i < P.size() - 2; i++)
+        // for every subsequent point in the list
+        for (size_t j = i + 1; j < P.size(); j++)
             // for every subsequent point in the list
-            for (size_t j = i + 1; j < P.size(); j++)
-                // for every subsequent point in the list
-                for (size_t k = j + 1; k < P.size(); k++) {
-                    // here, we now have picked three points from the given set
-       of
-                    // points that we can use
-                    // viz., P[i], P[j] and P[k]
-                    C.x = -0.5 * ((P[i].y * (P[j].x * P[j].x + P[j].y * P[j].y -
-                                             P[k].x * P[k].x - P[k].y * P[k].y)
-       + P[j].y * (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y
-       * P[i].y) + P[k].y * (P[i].x * P[i].x + P[i].y * P[i].y - P[j].x * P[j].x
-       - P[j].y * P[j].y)) / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y -
-       P[i].y) + P[k].x * (P[i].y - P[j].y))); C.y = 0.5 * ((P[i].x * (P[j].x *
-       P[j].x + P[j].y * P[j].y - P[k].x * P[k].x - P[k].y * P[k].y) + P[j].x *
-       (P[k].x * P[k].x + P[k].y * P[k].y - P[i].x * P[i].x - P[i].y * P[i].y) +
-                                  P[k].x * (P[i].x * P[i].x + P[i].y * P[i].y -
-                                            P[j].x * P[j].x - P[j].y * P[j].y))
-       / (P[i].x * (P[j].y - P[k].y) + P[j].x * (P[k].y - P[i].y) + P[k].x *
-       (P[i].y - P[j].y))); R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k])
-       * LenghtLine(P[k], P[i])) / (4 * TriangleArea(P[i], P[j], P[k])); if
-       (!PointInCircle(P, C, R)) { continue;
-                    }
-                    if (R <= minR) {
-                        minR = R;
-                        minC = C;
-                    }
+            for (size_t k = j + 1; k < P.size(); k++) {
+                // here, we now have picked three points from the given set of
+                // points that we can use
+                // viz., P[i], P[j] and P[k]
+                C.x = -0.5 * ((P[i].y * (P[j].x * P[j].x + P[j].y * P[j].y -
+                                         P[k].x * P[k].x - P[k].y * P[k].y) +
+                               P[j].y * (P[k].x * P[k].x + P[k].y * P[k].y -
+                                         P[i].x * P[i].x - P[i].y * P[i].y) +
+                               P[k].y * (P[i].x * P[i].x + P[i].y * P[i].y -
+                                         P[j].x * P[j].x - P[j].y * P[j].y)) /
+                              (P[i].x * (P[j].y - P[k].y) +
+                               P[j].x * (P[k].y - P[i].y) +
+                               P[k].x * (P[i].y - P[j].y)));
+                C.y = 0.5 * ((P[i].x * (P[j].x * P[j].x + P[j].y * P[j].y -
+                                        P[k].x * P[k].x - P[k].y * P[k].y) +
+                              P[j].x * (P[k].x * P[k].x + P[k].y * P[k].y -
+                                        P[i].x * P[i].x - P[i].y * P[i].y) +
+                              P[k].x * (P[i].x * P[i].x + P[i].y * P[i].y -
+                                        P[j].x * P[j].x - P[j].y * P[j].y)) /
+                             (P[i].x * (P[j].y - P[k].y) +
+                              P[j].x * (P[k].y - P[i].y) +
+                              P[k].x * (P[i].y - P[j].y)));
+                R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k]) *
+                     LenghtLine(P[k], P[i])) /
+                    (4 * TriangleArea(P[i], P[j], P[k]));
+                if (!PointInCircle(P, C, R)) {
+                    continue;
                 }
-    */
+                if (R <= minR) {
+                    minR = R;
+                    minC = C;
+                }
+            }
 
     // for each point in the list
     for (size_t i = 0; i < P.size() - 1; i++)
@@ -145,42 +152,42 @@ double circle(const std::vector<Point> &P) {
 /** Test case: result should be:
  * \n Circle with
  * \n radius 3.318493136080724
- * \n centre at (3.0454545454545454 1.3181818181818181)
+ * \n centre at (3.0454545454545454, 1.3181818181818181)
  */
 void test() {
-    std::vector<Point> Pv(5);
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(1, 3));
     Pv.push_back(Point(4, 1));
     Pv.push_back(Point(5, 4));
     Pv.push_back(Point(3, -2));
+    std::vector<Point> Pv;
     std::cout << circle(Pv) << std::endl;
 }
 
 /** Test case: result should be:
  * \n Circle with
  * \n radius 1.4142135623730951
- * \n centre at (1.0 1.0)
+ * \n centre at (1.0, 1.0)
  */
 void test2() {
-    std::vector<Point> Pv(4);
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(0, 2));
     Pv.push_back(Point(2, 2));
     Pv.push_back(Point(2, 0));
+    std::vector<Point> Pv;
     std::cout << circle(Pv) << std::endl;
 }
 
 /** Test case: result should be:
  * \n Circle with
  * \n radius 1.821078397711709
- * \n centre at (2.142857142857143 1.7857142857142856)
+ * \n centre at (2.142857142857143, 1.7857142857142856)
  */
 void test3() {
-    std::vector<Point> Pv(3);
     Pv.push_back(Point(0.5, 1));
     Pv.push_back(Point(3.5, 3));
     Pv.push_back(Point(2.5, 0));
+    std::vector<Point> Pv;
     std::cout << circle(Pv) << std::endl;
 }
 

From 5c7db7aba3e3da22ff9f877ef3d74a326eb48158 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:09:24 -0400
Subject: [PATCH 164/290] fixed syntax

---
 others/smallest-circle.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/others/smallest-circle.cpp b/others/smallest-circle.cpp
index 8f0231853..a0a2302fa 100644
--- a/others/smallest-circle.cpp
+++ b/others/smallest-circle.cpp
@@ -155,12 +155,12 @@ double circle(const std::vector<Point> &P) {
  * \n centre at (3.0454545454545454, 1.3181818181818181)
  */
 void test() {
+    std::vector<Point> Pv;
     Pv.push_back(Point(0, 0));
+    Pv.push_back(Point(5, 4));
     Pv.push_back(Point(1, 3));
     Pv.push_back(Point(4, 1));
-    Pv.push_back(Point(5, 4));
     Pv.push_back(Point(3, -2));
-    std::vector<Point> Pv;
     std::cout << circle(Pv) << std::endl;
 }
 
@@ -170,11 +170,11 @@ void test() {
  * \n centre at (1.0, 1.0)
  */
 void test2() {
+    std::vector<Point> Pv;
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(0, 2));
     Pv.push_back(Point(2, 2));
     Pv.push_back(Point(2, 0));
-    std::vector<Point> Pv;
     std::cout << circle(Pv) << std::endl;
 }
 
@@ -184,10 +184,10 @@ void test2() {
  * \n centre at (2.142857142857143, 1.7857142857142856)
  */
 void test3() {
+    std::vector<Point> Pv;
     Pv.push_back(Point(0.5, 1));
     Pv.push_back(Point(3.5, 3));
     Pv.push_back(Point(2.5, 0));
-    std::vector<Point> Pv;
     std::cout << circle(Pv) << std::endl;
 }
 

From c43e76286d123721c829f9b9cdeda6d9705d70ee Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:10:24 -0400
Subject: [PATCH 165/290] mark constructor function call as explicit

---
 others/smallest-circle.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/others/smallest-circle.cpp b/others/smallest-circle.cpp
index a0a2302fa..c1bd74de0 100644
--- a/others/smallest-circle.cpp
+++ b/others/smallest-circle.cpp
@@ -20,7 +20,7 @@ struct Point {
      * \param [in] a absicca (default = 0.0)
      * \param [in] b ordinate (default = 0.0)
      */
-    Point(double a = 0.f, double b = 0.f) {
+    explicit Point(double a = 0.f, double b = 0.f) {
         x = a;
         y = b;
     }

From 0994e6e028dc56965e98f8943680e40820926b1f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:23:52 -0400
Subject: [PATCH 166/290] minor documetnation

---
 others/smallest-circle.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/others/smallest-circle.cpp b/others/smallest-circle.cpp
index c1bd74de0..9ee4353eb 100644
--- a/others/smallest-circle.cpp
+++ b/others/smallest-circle.cpp
@@ -85,7 +85,7 @@ bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R) {
  * \returns radius of the circle
  */
 double circle(const std::vector<Point> &P) {
-    double minR = INT8_MAX;
+    double minR = INFINITY;
     double R;
     Point C;
     Point minC;
@@ -134,6 +134,7 @@ double circle(const std::vector<Point> &P) {
     for (size_t i = 0; i < P.size() - 1; i++)
         // for every subsequent point in the list
         for (size_t j = i + 1; j < P.size(); j++) {
+            // check for diameterically opposite points
             C.x = (P[i].x + P[j].x) / 2;
             C.y = (P[i].y + P[j].y) / 2;
             R = LenghtLine(C, P[i]);
@@ -182,12 +183,14 @@ void test2() {
  * \n Circle with
  * \n radius 1.821078397711709
  * \n centre at (2.142857142857143, 1.7857142857142856)
+ * @todo This test fails
  */
 void test3() {
     std::vector<Point> Pv;
     Pv.push_back(Point(0.5, 1));
     Pv.push_back(Point(3.5, 3));
     Pv.push_back(Point(2.5, 0));
+    Pv.push_back(Point(2, 1.5));
     std::cout << circle(Pv) << std::endl;
 }
 

From bc8fda9056f0fd52d42bd17bf58ce8309a6f3b0e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:25:00 -0400
Subject: [PATCH 167/290] sparse matrix docs

---
 others/sparse_matrix.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/others/sparse_matrix.cpp b/others/sparse_matrix.cpp
index d9878fda4..a358f0da4 100644
--- a/others/sparse_matrix.cpp
+++ b/others/sparse_matrix.cpp
@@ -1,10 +1,11 @@
 /** @file
  * A sparse matrix is a matrix which has number of zeroes greater than
- * \f$\frac{m*n}{2}\f$, where m and n are the dimensions of the matrix.
+ * \f$\frac{m\times n}{2}\f$, where m and n are the dimensions of the matrix.
  */
 
 #include <iostream>
 
+/** main function */
 int main() {
     int m, n;
     int counterZeros = 0;
@@ -30,7 +31,8 @@ int main() {
     // counts the zero's
     for (int i = 0; i < m; i++) {
         for (int j = 0; j < n; j++) {
-            if (a[i][j] == 0) counterZeros++;  // Counting number of zeroes
+            if (a[i][j] == 0)
+                counterZeros++;  // Counting number of zeroes
         }
     }
 

From 10bfe1399592c924f5756b0d1b0b8f0e78ceef9f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:29:44 -0400
Subject: [PATCH 168/290] addendum cpplint bugfix
 22b375c058cf2eec6c47990ae1b46e08d6cdd3ee

---
 .github/workflows/cpplint_modified_files.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/cpplint_modified_files.yml b/.github/workflows/cpplint_modified_files.yml
index 8de6a5e41..e21a5114e 100644
--- a/.github/workflows/cpplint_modified_files.yml
+++ b/.github/workflows/cpplint_modified_files.yml
@@ -37,7 +37,8 @@ jobs:
             sys.exit(0)
 
           print("cpplint:")
-          subprocess.run(["cpplint", "--filter=-legal/copyright"] + cpp_files, check=True, text=True)
+          for cpp_file in cpp_files:
+            subprocess.run(["cpplint", "--filter=-legal/copyright"] + cpp_file, check=True, text=True)
 
           print("g++:")
           # compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split())

From 05beeb5104f596523ec96e13c8c52b2e79dbae22 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:31:20 -0400
Subject: [PATCH 169/290] instead of concatenate, pass filename as argument

---
 .github/workflows/cpplint_modified_files.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/cpplint_modified_files.yml b/.github/workflows/cpplint_modified_files.yml
index e21a5114e..a5aa6a652 100644
--- a/.github/workflows/cpplint_modified_files.yml
+++ b/.github/workflows/cpplint_modified_files.yml
@@ -38,7 +38,7 @@ jobs:
 
           print("cpplint:")
           for cpp_file in cpp_files:
-            subprocess.run(["cpplint", "--filter=-legal/copyright"] + cpp_file, check=True, text=True)
+            subprocess.run(["cpplint", "--filter=-legal/copyright", cpp_file], check=True, text=True)
 
           print("g++:")
           # compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split())

From e7c6217097df8331a90233fede6b88467eb7a9a0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 14:33:48 -0400
Subject: [PATCH 170/290] filename must not contain spaces or dashes

---
 others/{smallest-circle.cpp => smallest_circle.cpp} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename others/{smallest-circle.cpp => smallest_circle.cpp} (100%)

diff --git a/others/smallest-circle.cpp b/others/smallest_circle.cpp
similarity index 100%
rename from others/smallest-circle.cpp
rename to others/smallest_circle.cpp

From ec8f4105582abb0e4e3d803b48b504dd73f8f199 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Thu, 28 May 2020 18:34:08 +0000
Subject: [PATCH 171/290] updating DIRECTORY.md

---
 DIRECTORY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index bbf405b7f..bd84673f0 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -148,7 +148,7 @@
   * [Paranthesis Matching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/paranthesis_matching.cpp)
   * [Pascal Triangle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/pascal_triangle.cpp)
   * [Primality Test](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/primality_test.cpp)
-  * [Smallest-Circle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/smallest-circle.cpp)
+  * [Smallest Circle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/smallest_circle.cpp)
   * [Sparse Matrix](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sparse_matrix.cpp)
   * [Spiral Print](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/spiral_print.cpp)
   * [Stairs Pattern](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/stairs_pattern.cpp)

From 4e12f5361f1ba6bdca8e7f3cb703ac04e514cb24 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:17:53 -0400
Subject: [PATCH 172/290] document string_fibonacci

---
 others/string_fibonacci.cpp | 80 ++++++++++++++++++++-----------------
 1 file changed, 43 insertions(+), 37 deletions(-)

diff --git a/others/string_fibonacci.cpp b/others/string_fibonacci.cpp
index e5475eec9..2617fc18f 100644
--- a/others/string_fibonacci.cpp
+++ b/others/string_fibonacci.cpp
@@ -1,82 +1,88 @@
-//This Programme returns the Nth fibonacci as a string.
-//The method used is manual addition with carry and placing it in a string which is called string addition
-//This makes it have no bounds or limits
+/**
+ * @file
+ * @brief This Programme returns the Nth fibonacci as a string.
+ *
+ * The method used is manual addition with carry and placing it in a string
+ * which is called string addition This makes it have no bounds or limits
+ *
+ * @see fibonacci_large.cpp, fibonacci_fast.cpp, fibonacci.cpp
+ */
 
 #include <iostream>
-#include <string>
+#ifdef _MSC_VER
+#include <string>  // use this for MS Visual C
+#else
+#include <cstring>  // otherwise
+#endif
 
-using namespace std;
-
-string add(string a, string b)
-{
-    string temp = "";
+/**
+ * function to add two string numbers
+ * \param [in] a first number in string to add
+ * \param [in] b second number in string to add
+ * \returns sum as a std::string
+ */
+std::string add(std::string a, std::string b) {
+    std::string temp = "";
 
     // carry flag
     int carry = 0;
 
     // fills up with zeros
-    while ((int)a.length() < (int)b.length())
-    {
+    while ((int)a.length() < (int)b.length()) {
         a = "0" + a;
     }
 
     // fills up with zeros
-    while ((int)b.length() < (int)a.length())
-    {
+    while ((int)b.length() < (int)a.length()) {
         b = "0" + b;
     }
 
     // adds the numbers a and b
-    for (int i = a.length() - 1; i >= 0; i--)
-    {
+    for (int i = a.length() - 1; i >= 0; i--) {
         char val = (char)(((a[i] - 48) + (b[i] - 48)) + 48 + carry);
-        if (val > 57)
-        {
+        if (val > 57) {
             carry = 1;
             val -= 10;
-        }
-        else
-        {
+        } else {
             carry = 0;
         }
         temp = val + temp;
     }
 
     // processes the carry flag
-    if (carry == 1)
-    {
+    if (carry == 1) {
         temp = "1" + temp;
     }
 
     // removes leading zeros.
-    while (temp[0] == '0' && temp.length() > 1)
-    {
+    while (temp[0] == '0' && temp.length() > 1) {
         temp = temp.substr(1);
     }
 
     return temp;
 }
 
-void fib_Accurate(long long n)
-{
-    string tmp = "";
-    string fibMinus1 = "1";
-    string fibMinus2 = "0";
-    for (long long i = 0; i < n; i++)
-    {
+/** Fibonacci iterator
+ * \param [in] n n^th Fibonacci number
+ */
+void fib_Accurate(long long n) {
+    std::string tmp = "";
+    std::string fibMinus1 = "1";
+    std::string fibMinus2 = "0";
+    for (long long i = 0; i < n; i++) {
         tmp = add(fibMinus1, fibMinus2);
         fibMinus2 = fibMinus1;
         fibMinus1 = tmp;
     }
-    cout << fibMinus2;
+    std::cout << fibMinus2;
 }
 
-int main()
-{
+/** main function */
+int main() {
     int n;
-    cout << "Enter whatever number N you want to find the fibonacci of\n";
-    cin >> n;
-    cout << n << " th Fibonacci is \n";
+    std::cout << "Enter whatever number N you want to find the fibonacci of\n";
+    std::cin >> n;
+    std::cout << n << " th Fibonacci is \n";
     fib_Accurate(n);
 
     return 0;

From ea8aaf963d739cae311f338bafc746f2fea37ee5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:18:48 -0400
Subject: [PATCH 173/290] move string fibonacci to math folder

---
 {others => math}/string_fibonacci.cpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {others => math}/string_fibonacci.cpp (100%)

diff --git a/others/string_fibonacci.cpp b/math/string_fibonacci.cpp
similarity index 100%
rename from others/string_fibonacci.cpp
rename to math/string_fibonacci.cpp

From 71bcc27e11e49901b695d1da9cf7f3bc3adaa9f6 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Thu, 28 May 2020 19:19:13 +0000
Subject: [PATCH 174/290] updating DIRECTORY.md

---
 DIRECTORY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index bd84673f0..51e840ef4 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -124,6 +124,7 @@
   * [Primes Up To Billion](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/primes_up_to_billion.cpp)
   * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sieve_of_eratosthenes.cpp)
   * [Sqrt Double](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/sqrt_double.cpp)
+  * [String Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/string_fibonacci.cpp)
 
 ## Operations On Datastructures
   * [Array Left Rotation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Array%20Left%20Rotation.cpp)
@@ -152,7 +153,6 @@
   * [Sparse Matrix](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/sparse_matrix.cpp)
   * [Spiral Print](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/spiral_print.cpp)
   * [Stairs Pattern](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/stairs_pattern.cpp)
-  * [String Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/string_fibonacci.cpp)
   * [Tower Of Hanoi](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/tower_of_hanoi.cpp)
   * [Vector Important Functions](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/vector_important_functions.cpp)
 

From 2216628678419a3b751162cbabf916caf8fd7543 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:19:27 -0400
Subject: [PATCH 175/290] update math fibonacci see-also links

---
 math/fibonacci.cpp       | 2 +-
 math/fibonacci_large.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index da7736564..e15cfc0cc 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -6,7 +6,7 @@
  * integer as input.
  * \f[\text{fib}(n) = \text{fib}(n-1) + \text{fib}(n-2)\f]
  *
- * @see fibonacci_large.cpp, fibonacci_fast.cpp
+ * @see fibonacci_large.cpp, fibonacci_fast.cpp, string_fibonacci.cpp
  */
 #include <cassert>
 #include <iostream>
diff --git a/math/fibonacci_large.cpp b/math/fibonacci_large.cpp
index 4545fdc9f..d9dbff799 100644
--- a/math/fibonacci_large.cpp
+++ b/math/fibonacci_large.cpp
@@ -7,7 +7,7 @@
  * Took 0.608246 seconds to compute 50,000^th Fibonacci
  * number that contains 10450 digits!
  *
- * @see fibonacci.cpp, fibonacci_fast.cpp
+ * @see fibonacci.cpp, fibonacci_fast.cpp, string_fibonacci.cpp
  */
 
 #include <cinttypes>

From 51affd4aa4f135b3c04b354660ebb84bf5862cf2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:27:49 -0400
Subject: [PATCH 176/290] document spiral print

---
 others/spiral_print.cpp | 83 +++++++++++++++++++++--------------------
 1 file changed, 43 insertions(+), 40 deletions(-)

diff --git a/others/spiral_print.cpp b/others/spiral_print.cpp
index e6e6899ef..02dc3183a 100644
--- a/others/spiral_print.cpp
+++ b/others/spiral_print.cpp
@@ -1,78 +1,81 @@
+/**
+ * @file
+ * @brief Print the elements of a matrix traversing it spirally
+ */
 #include <iostream>
-using namespace std;
-
-void genArray(int a[][10], int r, int c)
-{
 
+/** Arrange sequence of numbers from '1' in a matrix form
+ * \param [out] a matrix to fill
+ * \param [in] r number of rows
+ * \param [in] c number of columns
+ */
+void genArray(int **a, int r, int c) {
     int value = 1;
-    for (int i = 0; i < r; i++)
-    {
-        for (int j = 0; j < c; j++)
-        {
+    for (int i = 0; i < r; i++) {
+        for (int j = 0; j < c; j++) {
             a[i][j] = value;
-            cout << a[i][j] << " ";
+            std::cout << a[i][j] << " ";
             value++;
         }
-        cout << endl;
+        std::cout << std::endl;
     }
 }
-void spiralPrint(int a[][10], int r, int c)
-{
 
+/** Traverse the matrix spirally and print the sequence of elements
+ * \param [in] a matrix to read from
+ * \param [in] r number of rows
+ * \param [in] c number of columns
+ */
+void spiralPrint(int **a, int r, int c) {
     int startRow = 0, endRow = r - 1;
     int startCol = 0, endCol = c - 1;
     int cnt = 0;
 
-    while (startRow <= endRow && startCol <= endCol)
-    {
-
-        ///Print start row
-        for (int i = startCol; i <= endCol; i++, cnt++)
-        {
-            cout << a[startRow][i] << " ";
+    while (startRow <= endRow && startCol <= endCol) {
+        /// Print start row
+        for (int i = startCol; i <= endCol; i++, cnt++) {
+            std::cout << a[startRow][i] << " ";
         }
         startRow++;
 
-        ///Print the end col
-        for (int i = startRow; i <= endRow; i++, cnt++)
-        {
-            cout << a[i][endCol] << " ";
+        /// Print the end col
+        for (int i = startRow; i <= endRow; i++, cnt++) {
+            std::cout << a[i][endCol] << " ";
         }
         endCol--;
 
-        ///Print the end row
-        if (cnt == r * c)
-        {
+        /// Print the end row
+        if (cnt == r * c) {
             break;
         }
 
-        for (int i = endCol; i >= startCol; i--, cnt++)
-        {
-            cout << a[endRow][i] << " ";
+        for (int i = endCol; i >= startCol; i--, cnt++) {
+            std::cout << a[endRow][i] << " ";
         }
         endRow--;
 
-        ///Print the start Col
-        if (cnt == r * c)
-        {
+        /// Print the start Col
+        if (cnt == r * c) {
             break;
         }
-        for (int i = endRow; i >= startRow; i--, cnt++)
-        {
-            cout << a[i][startCol] << " ";
+        for (int i = endRow; i >= startRow; i--, cnt++) {
+            std::cout << a[i][startCol] << " ";
         }
         startCol++;
     }
 }
 
-int main()
-{
-    int a[10][10];
-
+/** main function */
+int main() {
     int r, c;
-    cin >> r >> c;
+    std::cin >> r >> c;
+    int **a = new int *[r];
+    for (int i = 0; i < r; i++) a[i] = new int[c];
+
     genArray(a, r, c);
     spiralPrint(a, r, c);
 
+    for (int i = 0; i < r; i++) delete[] a[i];
+    delete[] a;
     return 0;
 }

From 1e3247895045243e4e45f2ae6b60f6fb771805ce Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:27:58 -0400
Subject: [PATCH 177/290] document stairs print

---
 others/stairs_pattern.cpp | 60 +++++++++++++++++++++------------------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/others/stairs_pattern.cpp b/others/stairs_pattern.cpp
index 281446a2f..a3b8b0a44 100644
--- a/others/stairs_pattern.cpp
+++ b/others/stairs_pattern.cpp
@@ -1,31 +1,35 @@
-/*
-This program is use to print the following pattern
-   **
-   **
-  ****
-  ****
- ******
- ******
-********
-********
-where number of pairs line is given by user  
+/**
+ * @file
+@brief This program is use to print the following pattern<pre>
+   \*\*
+   \*\*
+  \*\*\*\*
+  \*\*\*\*
+ \*\*\*\*\*\*
+ \*\*\*\*\*\*
+\*\*\*\*\*\*\*\*
+********</pre>
+where number of pairs line is given by user
 */
-#include<iostream>
+#include <iostream>
+
+/** main function */
 int main() {
-int l, st = 2, x, r, z, n, sp;
-std::cout << "enter Index ";
-std::cin >> x;
-z = x;
-for (r = 1; r <= x; r++) {
-z = z - 1;
-for (n = 1; n <= 2; n++) {
-for (sp = 1; sp <= z; sp++) {
-std::cout << " ";
+    int l, st = 2, x, r, z, n, sp;
+    std::cout << "enter Index ";
+    std::cin >> x;
+    z = x;
+    for (r = 1; r <= x; r++) {
+        z = z - 1;
+        for (n = 1; n <= 2; n++) {
+            for (sp = 1; sp <= z; sp++) {
+                std::cout << " ";
+            }
+            for (l = 1; l <= st; l++) {
+                std::cout << "*";
+            }
+            std::cout << std::endl;
+        }
+        st = st + 2;
+    }
 }
-for (l = 1; l <= st; l++) {
-std::cout << "*";
-}
-std::cout <<"\n";
-}
-st = st + 2;
-}}

From 1e5f97c042564ffccf9226228b186752c82db084 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:50:35 -0400
Subject: [PATCH 178/290] document towers of hanoi

---
 others/tower_of_hanoi.cpp | 123 ++++++++++++++++++++------------------
 1 file changed, 66 insertions(+), 57 deletions(-)

diff --git a/others/tower_of_hanoi.cpp b/others/tower_of_hanoi.cpp
index 5783d6a98..d6c229617 100644
--- a/others/tower_of_hanoi.cpp
+++ b/others/tower_of_hanoi.cpp
@@ -1,73 +1,82 @@
+/**
+ * @file
+ * @brief Solve the [Tower of
+ * Hanoi](https://en.wikipedia.org/wiki/Tower_of_Hanoi) problem.
+ */
 #include <iostream>
-using namespace std;
 
-struct tower
-{
-	int values[10];
-	int top;
+/**
+ * Define the state of tower
+ */
+struct tower {
+    //! Values in the tower
+    int values[10];
+    //! top tower ID
+    int top;
 } F, U, T;
 
-void show()
-{
-	cout << "\n\n\tF : ";
-	for (int i = 0; i < F.top; i++)
-	{
-		cout << F.values[i] << "\t";
-	}
-	cout << "\n\tU : ";
-	for (int i = 0; i < U.top; i++)
-	{
-		cout << U.values[i] << "\t";
-	}
-	cout << "\n\tT : ";
-	for (int i = 0; i < T.top; i++)
-	{
-		cout << T.values[i] << "\t";
-	}
+/** Display the towers */
+void show() {
+    std::cout << "\n\n\tF : ";
+    for (int i = 0; i < F.top; i++) {
+        std::cout << F.values[i] << "\t";
+    }
+    std::cout << "\n\tU : ";
+    for (int i = 0; i < U.top; i++) {
+        std::cout << U.values[i] << "\t";
+    }
+    std::cout << "\n\tT : ";
+    for (int i = 0; i < T.top; i++) {
+        std::cout << T.values[i] << "\t";
+    }
 }
 
-void mov(tower &From, tower &To)
-{
-	--From.top;
-	To.values[To.top] = From.values[From.top];
-	++To.top;
+/** Move one disc from one tower to another
+ * \param [in,out] From tower to move disk *from*
+ * \param [in,out] To  tower to move disk *to*
+ */
+void mov(tower &From, tower &To) {
+    --From.top;
+    To.values[To.top] = From.values[From.top];
+    ++To.top;
 }
 
-void TH(int n, tower &From, tower &Using, tower &To)
-{
-
-	if (n == 1)
-	{
-		mov(From, To);
-		show();
-	}
-	else
-	{
-		TH(n - 1, From, To, Using);
-		mov(From, To);
-		show();
-		TH(n - 1, Using, From, To);
-	}
+/**
+ * Recursive algorithm to solve the puzzle
+ * \param [in] n starting number of disks
+ * \param [in,out] From  tower to move disks from
+ * \param [in,out] Using temporary tower for the puzzle
+ * \param [in,out] To  tower to move disk to
+ */
+void TH(int n, tower &From, tower &Using, tower &To) {
+    if (n == 1) {
+        mov(From, To);
+        show();
+    } else {
+        TH(n - 1, From, To, Using);
+        mov(From, To);
+        show();
+        TH(n - 1, Using, From, To);
+    }
 }
 
-int main()
-{
-	F.top = 0;
-	U.top = 0;
-	T.top = 0;
+/** Main function */
+int main() {
+    F.top = 0;
+    U.top = 0;
+    T.top = 0;
 
-	int no;
+    int no;
 
-	cout << "\nEnter number of discs : ";
-	cin >> no;
+    std::cout << "\nEnter number of discs : ";
+    std::cin >> no;
 
-	for (int i = no; i > 0; i--)
-	{
-		F.values[F.top++] = i;
-	};
+    for (int i = no; i > 0; i--) {
+        F.values[F.top++] = i;
+    }
 
-	show();
-	TH(no, F, U, T);
+    show();
+    TH(no, F, U, T);
 
-	return 0;
+    return 0;
 }

From 2412f95964221bf7707ad435b91ba5179e8e47a0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:55:46 -0400
Subject: [PATCH 179/290] document vector sort, reverse example

---
 others/vector_important_functions.cpp | 60 +++++++++++++--------------
 1 file changed, 29 insertions(+), 31 deletions(-)

diff --git a/others/vector_important_functions.cpp b/others/vector_important_functions.cpp
index e0a70eeda..d23ff9c97 100644
--- a/others/vector_important_functions.cpp
+++ b/others/vector_important_functions.cpp
@@ -1,45 +1,43 @@
-// A C++ program to demonstrate working of sort(),
-// reverse()
+/**
+ * @file
+ * @brief A C++ program to demonstrate working of std::sort(), std::reverse()
+ */
 #include <algorithm>
 #include <iostream>
+#include <numeric>  // For accumulate operation
 #include <vector>
-#include <numeric> //For accumulate operation
-using namespace std;
 
-int main()
-{
-	// Initializing vector with array values
-	int arr[] = {10, 20, 5, 23 ,42 , 15};
-	int n = sizeof(arr)/sizeof(arr[0]);
-	vector<int> vect(arr, arr+n);
+/** Main function */
+int main() {
+    // Initializing vector with array values
+    int arr[] = {10, 20, 5, 23, 42, 15};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    std::vector<int> vect(arr, arr + n);
 
-	cout << "Vector is: ";
-	for (int i=0; i<n; i++)
-		cout << vect[i] << " ";
+    std::cout << "Vector is: ";
+    for (int i = 0; i < n; i++) std::cout << vect[i] << " ";
 
-	// Sorting the Vector in Ascending order
-	sort(vect.begin(), vect.end());
+    // Sorting the Vector in Ascending order
+    std::sort(vect.begin(), vect.end());
 
-	cout << "\nVector after sorting is: ";
-	for (int i=0; i<n; i++)
-	cout << vect[i] << " ";
+    std::cout << "\nVector after sorting is: ";
+    for (int i = 0; i < n; i++) std::cout << vect[i] << " ";
 
-	// Reversing the Vector
-	reverse(vect.begin(), vect.end());
+    // Reversing the Vector
+    std::reverse(vect.begin(), vect.end());
 
-	cout << "\nVector after reversing is: ";
-	for (int i=0; i<6; i++)
-		cout << vect[i] << " ";
+    std::cout << "\nVector after reversing is: ";
+    for (int i = 0; i < 6; i++) std::cout << vect[i] << " ";
 
-	cout << "\nMaximum element of vector is: ";
-	cout << *max_element(vect.begin(), vect.end());
+    std::cout << "\nMaximum element of vector is: ";
+    std::cout << *max_element(vect.begin(), vect.end());
 
-	cout << "\nMinimum element of vector is: ";
-	cout << *min_element(vect.begin(), vect.end());
+    std::cout << "\nMinimum element of vector is: ";
+    std::cout << *min_element(vect.begin(), vect.end());
 
-	// Starting the summation from 0
-	cout << "\nThe summation of vector elements is: ";
-	cout << accumulate(vect.begin(), vect.end(), 0);
+    // Starting the summation from 0
+    std::cout << "\nThe summation of vector elements is: ";
+    std::cout << accumulate(vect.begin(), vect.end(), 0);
 
-	return 0;
+    return 0;
 }

From e12a5d4b5d744a48ed30f0969a24fbde407bdd0e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 15:59:28 -0400
Subject: [PATCH 180/290] remove un-necessary typecast & use uint64_t

---
 math/string_fibonacci.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/math/string_fibonacci.cpp b/math/string_fibonacci.cpp
index 2617fc18f..eb9b6d7e1 100644
--- a/math/string_fibonacci.cpp
+++ b/math/string_fibonacci.cpp
@@ -28,18 +28,18 @@ std::string add(std::string a, std::string b) {
     int carry = 0;
 
     // fills up with zeros
-    while ((int)a.length() < (int)b.length()) {
+    while (a.length() < b.length()) {
         a = "0" + a;
     }
 
     // fills up with zeros
-    while ((int)b.length() < (int)a.length()) {
+    while (b.length() < a.length()) {
         b = "0" + b;
     }
 
     // adds the numbers a and b
     for (int i = a.length() - 1; i >= 0; i--) {
-        char val = (char)(((a[i] - 48) + (b[i] - 48)) + 48 + carry);
+        char val = static_cast<char>(((a[i] - 48) + (b[i] - 48)) + 48 + carry);
         if (val > 57) {
             carry = 1;
             val -= 10;
@@ -65,11 +65,11 @@ std::string add(std::string a, std::string b) {
 /** Fibonacci iterator
  * \param [in] n n^th Fibonacci number
  */
-void fib_Accurate(long long n) {
+void fib_Accurate(uint64_t n) {
     std::string tmp = "";
     std::string fibMinus1 = "1";
     std::string fibMinus2 = "0";
-    for (long long i = 0; i < n; i++) {
+    for (uint64_t i = 0; i < n; i++) {
         tmp = add(fibMinus1, fibMinus2);
         fibMinus2 = fibMinus1;
         fibMinus1 = tmp;

From b9b930213fc2a2e7c86b335cc70099c45a6c24ea Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 16:05:43 -0400
Subject: [PATCH 181/290] use pointers instead of non-const references and
 globals

---
 others/tower_of_hanoi.cpp | 37 ++++++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 17 deletions(-)

diff --git a/others/tower_of_hanoi.cpp b/others/tower_of_hanoi.cpp
index d6c229617..323b2e424 100644
--- a/others/tower_of_hanoi.cpp
+++ b/others/tower_of_hanoi.cpp
@@ -13,21 +13,22 @@ struct tower {
     int values[10];
     //! top tower ID
     int top;
-} F, U, T;
+};
 
 /** Display the towers */
-void show() {
+void show(const struct tower *const F, const struct tower *const T,
+          const struct tower *const U) {
     std::cout << "\n\n\tF : ";
-    for (int i = 0; i < F.top; i++) {
-        std::cout << F.values[i] << "\t";
+    for (int i = 0; i < F->top; i++) {
+        std::cout << F->values[i] << "\t";
     }
     std::cout << "\n\tU : ";
-    for (int i = 0; i < U.top; i++) {
-        std::cout << U.values[i] << "\t";
+    for (int i = 0; i < U->top; i++) {
+        std::cout << U->values[i] << "\t";
     }
     std::cout << "\n\tT : ";
-    for (int i = 0; i < T.top; i++) {
-        std::cout << T.values[i] << "\t";
+    for (int i = 0; i < T->top; i++) {
+        std::cout << T->values[i] << "\t";
     }
 }
 
@@ -35,10 +36,10 @@ void show() {
  * \param [in,out] From tower to move disk *from*
  * \param [in,out] To  tower to move disk *to*
  */
-void mov(tower &From, tower &To) {
-    --From.top;
-    To.values[To.top] = From.values[From.top];
-    ++To.top;
+void mov(tower *From, tower *To) {
+    --From->top;
+    To->values[To->top] = From->values[From->top];
+    ++To->top;
 }
 
 /**
@@ -48,20 +49,22 @@ void mov(tower &From, tower &To) {
  * \param [in,out] Using temporary tower for the puzzle
  * \param [in,out] To  tower to move disk to
  */
-void TH(int n, tower &From, tower &Using, tower &To) {
+void TH(int n, tower *From, tower *Using, tower *To) {
     if (n == 1) {
         mov(From, To);
-        show();
+        show(From, To, Using);
     } else {
         TH(n - 1, From, To, Using);
         mov(From, To);
-        show();
+        show(From, To, Using);
         TH(n - 1, Using, From, To);
     }
 }
 
 /** Main function */
 int main() {
+    struct tower F, U, T;
+
     F.top = 0;
     U.top = 0;
     T.top = 0;
@@ -75,8 +78,8 @@ int main() {
         F.values[F.top++] = i;
     }
 
-    show();
-    TH(no, F, U, T);
+    show(&F, &T, &U);
+    TH(no, &F, &U, &T);
 
     return 0;
 }

From 9ef8100a52db10d0581ea816c98de27e27fbf1eb Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 16:37:03 -0400
Subject: [PATCH 182/290] added see also reference to fibonacci

---
 math/fibonacci_fast.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/math/fibonacci_fast.cpp b/math/fibonacci_fast.cpp
index dc59742b8..08cced351 100644
--- a/math/fibonacci_fast.cpp
+++ b/math/fibonacci_fast.cpp
@@ -11,7 +11,7 @@
  * found if we have already found n/2th or (n+1)/2th fibonacci It is a property
  * of fibonacci similar to matrix exponentiation.
  *
- * @see fibonacci_large.cpp, fibonacci.cpp
+ * @see fibonacci_large.cpp, fibonacci.cpp, string_fibonacci.cpp
  */
 
 #include <cinttypes>

From e52da1db6ea46fac9f68ae8b492fbbb6a87b5190 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 16:40:08 -0400
Subject: [PATCH 183/290] documented factorial

---
 math/factorial.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/math/factorial.cpp b/math/factorial.cpp
index 8b13eb52d..353f0b16b 100644
--- a/math/factorial.cpp
+++ b/math/factorial.cpp
@@ -1,14 +1,17 @@
-// C++ program to find factorial of given number
-#include<iostream>
+/**
+ * @file
+ * @brief C++ program to find factorial of given number
+ */
+#include <iostream>
 
-// function to find factorial of given number
+/** function to find factorial of given number */
 unsigned int factorial(unsigned int n) {
     if (n == 0)
         return 1;
     return n * factorial(n - 1);
 }
 
-// Driver code
+/** Main function */
 int main() {
     int num = 5;
     std::cout << "Factorial of " << num << " is " << factorial(num)

From c559ebcedbf811333009a9cc27cc782c75f4a338 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 16:41:07 -0400
Subject: [PATCH 184/290] replace printf & scanf with std::cout and std::cin

---
 math/power_for_huge_numbers.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/math/power_for_huge_numbers.cpp b/math/power_for_huge_numbers.cpp
index 5cb1ae514..301767d66 100644
--- a/math/power_for_huge_numbers.cpp
+++ b/math/power_for_huge_numbers.cpp
@@ -81,10 +81,10 @@ void power(int x, int n) {
 /** Main function */
 int main() {
     int exponent, base;
-    printf("Enter base ");
-    scanf("%id \n", &base);
-    printf("Enter exponent ");
-    scanf("%id", &exponent);
+    std::cout << "Enter base ";
+    std::cin >> base;
+    std::cout << "Enter exponent ";
+    std::cin >> exponent;
     power(base, exponent);
     return 0;
 }

From 2683b9d6ede5176b01f22bfe483be6579d6c7533 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 16:43:03 -0400
Subject: [PATCH 185/290] fix happy number code and documetnation

---
 others/happy_number.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/others/happy_number.cpp b/others/happy_number.cpp
index dacb2b8c4..b1debaa54 100644
--- a/others/happy_number.cpp
+++ b/others/happy_number.cpp
@@ -1,7 +1,7 @@
 /**
- * A [happy number](https://en.wikipedia.org/wiki/Happy_number) is a decimal
- * number whose sum of digits is calculated until the sum is a single digit, and
- * this sum turns out to be 1.
+ * @file
+ * @brief A happy number is a number whose sum of digits is calculated until the
+ * sum is a single digit, and this sum turns out to be 1
  */
 
 #include <iostream>

From 2f3cb1adaa9a88d679736d49a5a6d35d03f7057b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 16:34:29 -0400
Subject: [PATCH 186/290] document probability addition rule

---
 probability/addition_rule.cpp | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/probability/addition_rule.cpp b/probability/addition_rule.cpp
index f19955071..780951489 100644
--- a/probability/addition_rule.cpp
+++ b/probability/addition_rule.cpp
@@ -1,28 +1,42 @@
+/**
+ * @file
+ * @brief Addition rule of probabilities
+ */
 #include <iostream>
 
-// calculates the probability of the events A or B for independent events
-
+/**
+ * calculates the probability of the independent events A or B for independent
+ * events
+ * \parama [in] A probability of event A
+ * \parama [in] B probability of event B
+ * \returns probability of A and B
+ */
 double addition_rule_independent(double A, double B) {
     return (A + B) - (A * B);
 }
 
-// calculates the probability of the events A or B for dependent events
-// note that if value of B_given_A is unknown, use chainrule to find it
-
+/** Calculates the probability of the events A or B for dependent events
+ * note that if value of B_given_A is unknown, use chainrule to find it
+ * \parama [in] A probability of event A
+ * \parama [in] B probability of event B
+ * \parama [in] B_given_A probability of event B condition A
+ * \returns probability of A and B
+ */
 double addition_rule_dependent(double A, double B, double B_given_A) {
     return (A + B) - (A * B_given_A);
 }
 
+/** Main function */
 int main() {
     double A = 0.5;
     double B = 0.25;
     double B_given_A = 0.05;
 
-    std::cout << "independent P(A or B) = "
-    << addition_rule_independent(A, B) << std::endl;
+    std::cout << "independent P(A or B) = " << addition_rule_independent(A, B)
+              << std::endl;
 
     std::cout << "dependent P(A or B) = "
-    << addition_rule_dependent(A, B, B_given_A) << std::endl;
+              << addition_rule_dependent(A, B, B_given_A) << std::endl;
 
     return 0;
 }

From 589dceb5b38b409dce072a87112327db23a73f34 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 16:34:37 -0400
Subject: [PATCH 187/290] document bayes theorem

---
 probability/bayes_theorem.cpp | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/probability/bayes_theorem.cpp b/probability/bayes_theorem.cpp
index d30be6c9a..aaa557a94 100644
--- a/probability/bayes_theorem.cpp
+++ b/probability/bayes_theorem.cpp
@@ -1,24 +1,28 @@
+/**
+ * @file
+ * @brief [Bayes' theorem](https://en.wikipedia.org/wiki/Bayes%27_theorem)
+ *
+ * Bayes' theorem allows one to find \f$P(A|B)\f$ given \f$P(B|A)\f$ or
+ * \f$P(B|A)\f$ given \f$P(A|B)\f$ and \f$P(A)\f$ and \f$P(B)\f$.\n
+ * Note that \f$P(A|B)\f$ is read 'The probability of A given that the event B
+ * has occured'.
+ */
 #include <iostream>
 
-// bayes' theorem > https://en.wikipedia.org/wiki/Bayes%27_theorem
-
-// bayes' theorem allows one to find P(A|B) given P(B|A)
-// or P(B|A) given P(A|B) and P(A) and P(B)
-
-// note P(A|B) is read 'The probability of A given that the event B has occured'
-
-// returns P(A|B)
-
+/** returns P(A|B)
+ */
 double bayes_AgivenB(double BgivenA, double A, double B) {
     return (BgivenA * A) / B;
 }
 
-// returns P(B|A)
-
+/** returns P(B|A)
+ */
 double bayes_BgivenA(double AgivenB, double A, double B) {
     return (AgivenB * B) / A;
 }
 
+/** Main function
+ */
 int main() {
     double A = 0.01;
     double B = 0.1;

From 70473004643aebc9232d2f57bd95764b99dd9d0c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 17:00:39 -0400
Subject: [PATCH 188/290] add probability folder to cmake

---
 CMakeLists.txt             |  1 +
 probability/CMakeLists.txt | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 probability/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c072de6e0..70c5b9b2c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -57,6 +57,7 @@ add_subdirectory(others)
 add_subdirectory(search)
 add_subdirectory(strings)
 add_subdirectory(sorting)
+add_subdirectory(probability)
 add_subdirectory(computer_oriented_statistical_methods)
 
 if(USE_OPENMP)
diff --git a/probability/CMakeLists.txt b/probability/CMakeLists.txt
new file mode 100644
index 000000000..0e0b7b7f0
--- /dev/null
+++ b/probability/CMakeLists.txt
@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/probability")
+
+endforeach( testsourcefile ${APP_SOURCES} )

From 9a7018c5c89af5ef5f782c4a0b54ed2d933ccbf4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 17:14:39 -0400
Subject: [PATCH 189/290] document poisson distribution

---
 probability/poisson_dist.cpp | 61 ++++++++++++++++++++++--------------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/probability/poisson_dist.cpp b/probability/poisson_dist.cpp
index 345363368..6a2a377c3 100644
--- a/probability/poisson_dist.cpp
+++ b/probability/poisson_dist.cpp
@@ -1,26 +1,32 @@
-#include <iostream>
+/**
+ * @file
+ * @brief [Poisson
+ * statistics](https://en.wikipedia.org/wiki/Poisson_distribution)
+ *
+ * The Poisson distribution counts how many
+ * events occur over a set time interval.
+ */
 #include <cmath>
+#include <iostream>
 
-// The Poisson distribution counts how many
-// events occur over a set time interval
-// https://en.wikipedia.org/wiki/Poisson_distribution
-
-// calculate the events per unit time
-// e.g 5 dollars every 2 mins = 5 / 2 = 2.5
-
+/**
+ * poisson rate:\n
+ * calculate the events per unit time\n
+ * e.g 5 dollars every 2 mins = 5 / 2 = 2.5
+ */
 double poisson_rate(double events, double timeframe) {
     return events / timeframe;
 }
 
-// calculate the expected value over a time
-// e.g rate of 2.5 over 10 mins = 2.5 x 10 = 25
-
-double poisson_expected(double rate, double time) {
-    return rate * time;
-}
-
-// find the factorial of a given number
+/**
+ *  calculate the expected value over a time
+ * e.g rate of 2.5 over 10 mins = 2.5 x 10 = 25
+ */
+double poisson_expected(double rate, double time) { return rate * time; }
 
+/**
+ * Compute factorial of a given number
+ */
 double fact(double x) {
     double x_fact = x;
     for (int i = x - 1; i > 0; i--) {
@@ -33,14 +39,18 @@ double fact(double x) {
     return x_fact;
 }
 
-// find the probability of x successes in a Poisson dist
-
+/**
+ * Find the probability of x successes in a Poisson dist.
+ * \f[p(\mu,x) = \frac{\mu^x e^{-\mu}}{x!}\f]
+ */
 double poisson_x_successes(double expected, double x) {
-    return (pow(expected, x) * exp(-expected)) / fact(x);
+    return (std::pow(expected, x) * std::exp(-expected)) / fact(x);
 }
 
-// probability of a success in range for Poisson dist (inclusive, inclusive)
-
+/**
+ * probability of a success in range for Poisson dist (inclusive, inclusive)
+ * \f[P = \sum_i p(\mu,i)\f]
+ */
 double poisson_range_successes(double expected, double lower, double upper) {
     double probability = 0;
     for (int i = lower; i <= upper; i++) {
@@ -49,6 +59,9 @@ double poisson_range_successes(double expected, double lower, double upper) {
     return probability;
 }
 
+/**
+ * main function
+ */
 int main() {
     double rate, expected;
     rate = poisson_rate(3, 1);
@@ -57,10 +70,10 @@ int main() {
     expected = poisson_expected(rate, 2);
     std::cout << "Poisson expected : " << expected << std::endl;
 
-    std::cout << "Poisson 0 successes : "
-        <<poisson_x_successes(expected, 0) <<std::endl;
+    std::cout << "Poisson 0 successes : " << poisson_x_successes(expected, 0)
+              << std::endl;
     std::cout << "Poisson 0-8 successes : "
-        << poisson_range_successes(expected, 0, 8) <<std::endl;
+              << poisson_range_successes(expected, 0, 8) << std::endl;
 
     return 0;
 }

From c6258d2cc7263184b6cdbc9c8f12f7e6d544013b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 17:38:50 -0400
Subject: [PATCH 190/290] documented binomial distribution

---
 probability/binomial_dist.cpp | 103 ++++++++++++++++++++--------------
 1 file changed, 61 insertions(+), 42 deletions(-)

diff --git a/probability/binomial_dist.cpp b/probability/binomial_dist.cpp
index b21a3e0fc..1f30c5048 100644
--- a/probability/binomial_dist.cpp
+++ b/probability/binomial_dist.cpp
@@ -1,81 +1,100 @@
-#include <iostream>
+/**
+ * @file
+ * @brief [Binomial
+ * distribution](https://en.wikipedia.org/wiki/Binomial_distribution) example
+ *
+ * The binomial distribution models the number of
+ * successes in a sequence of n independent events
+ *
+ * Summary of variables used:
+ * * n : number of trials
+ * * p : probability of success
+ * * x : desired successes
+ */
 #include <cmath>
+#include <iostream>
 
-// the binomial distribution models the number of
-// successes in a sequence of n independent events
+/** finds the expected value of a binomial distribution
+ * \param [in] n
+ * \param [in] p
+ * \returns \f$\mu=np\f$
+ */
+double binomial_expected(double n, double p) { return n * p; }
 
-// n : number of trials
-// p : probability of success
-// x : desired successes
-
-// finds the expected value of a binomial distribution
-
-double binomial_expected(double n, double p) {
-    return n * p;
-}
-
-// finds the variance of the binomial distribution
-
-double binomial_variance(double n, double p) {
-    return n * p * (1 - p);
-}
-
-// finds the standard deviation of the binomial distribution
+/** finds the variance of the binomial distribution
+ * \param [in] n
+ * \param [in] p
+ * \returns \f$\sigma^2 = n\cdot p\cdot (1-p)\f$
+ */
+double binomial_variance(double n, double p) { return n * p * (1 - p); }
 
+/** finds the standard deviation of the binomial distribution
+ * \param [in] n
+ * \param [in] p
+ * \returns \f$\sigma = \sqrt{\sigma^2} = \sqrt{n\cdot p\cdot (1-p)}\f$
+ */
 double binomial_standard_deviation(double n, double p) {
-    return sqrt(binomial_variance(n, p));
+    return std::sqrt(binomial_variance(n, p));
 }
 
-// Computes n choose r
-// n being the trials and r being the desired successes
-
+/** Computes n choose r
+ * \param [in] n
+ * \param [in] r
+ * \returns \f$\displaystyle {n\choose r} =
+ * \frac{n!}{r!(n-r)!} = \frac{n\times(n-1)\times(n-2)\times\cdots(n-r)}{r!}
+ * \f$
+ */
 double nCr(double n, double r) {
     double numerator = n;
     double denominator = r;
 
-    for (int i = n - 1 ; i >= ((n - r) + 1); i--) {
+    for (int i = n - 1; i >= ((n - r) + 1); i--) {
         numerator *= i;
     }
 
-    for (int i = 1; i < r ; i++) {
+    for (int i = 1; i < r; i++) {
         denominator *= i;
     }
 
     return numerator / denominator;
 }
 
-// calculates the probability of exactly x successes
-
+/** calculates the probability of exactly x successes
+ * \returns \f$\displaystyle P(n,p,x) = {n\choose x} p^x (1-p)^{n-x}\f$
+ */
 double binomial_x_successes(double n, double p, double x) {
-    return nCr(n, x) * pow(p, x) * pow(1-p, n-x);
+    return nCr(n, x) * std::pow(p, x) * std::pow(1 - p, n - x);
 }
 
-// calculates the probability of a result within a range (inclusive, inclusive)
-
-double binomial_range_successes(
-    double n, double p, double lower_bound, double upper_bound) {
+/** calculates the probability of a result within a range (inclusive, inclusive)
+ * \returns \f$\displaystyle \left.P(n,p)\right|_{x_0}^{x_1} =
+ * \sum_{i=x_0}^{x_1} P(i)
+ * =\sum_{i=x_0}^{x_1} {n\choose i} p^i (1-p)^{n-i}\f$
+ */
+double binomial_range_successes(double n, double p, double lower_bound,
+                                double upper_bound) {
     double probability = 0;
     for (int i = lower_bound; i <= upper_bound; i++) {
-        probability += nCr(n, i) * pow(p, i) * pow(1 - p, n - i);
+        probability += nCr(n, i) * std::pow(p, i) * std::pow(1 - p, n - i);
     }
     return probability;
 }
 
+/** main function */
 int main() {
-    std::cout << "expected value : "
-        <<binomial_expected(100, 0.5) << std::endl;
+    std::cout << "expected value : " << binomial_expected(100, 0.5)
+              << std::endl;
 
-    std::cout << "variance : "
-        << binomial_variance(100, 0.5) << std::endl;
+    std::cout << "variance : " << binomial_variance(100, 0.5) << std::endl;
 
     std::cout << "standard deviation : "
-        << binomial_standard_deviation(100, 0.5) << std::endl;
+              << binomial_standard_deviation(100, 0.5) << std::endl;
 
-    std::cout << "exactly 30 successes : "
-        << binomial_x_successes(100, 0.5, 30) << std::endl;
+    std::cout << "exactly 30 successes : " << binomial_x_successes(100, 0.5, 30)
+              << std::endl;
 
     std::cout << "45 or more successes : "
-        << binomial_range_successes(100, 0.5, 45, 100) << std::endl;
+              << binomial_range_successes(100, 0.5, 45, 100) << std::endl;
 
     return 0;
 }

From b9c71a1d6665ea5e789703aa68ac37fd727d9d49 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 17:39:08 -0400
Subject: [PATCH 191/290] added AMS extenstions to MATHJAX in doxygen

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 70c5b9b2c..95c09d8e2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,6 +33,7 @@ if(DOXYGEN_FOUND)
     set(DOXYGEN_STRIP_CODE_COMMENTS NO)
     set(DOXYGEN_BUILTIN_STL_SUPPORT YES)
     set(DOXYGEN_FILE_PATTERNS *.cpp *.h *.hpp *.md)
+    set(DOXYGEN_MATHJAX_EXTENSIONS  TeX/AMSmath TeX/AMSsymbols)
     set(DOXYGEN_TAGFILES "doc/cppreference-doxygen-web.tag.xml=http://en.cppreference.com/w/")
     if(MSVC)
         set(DOXYGEN_CPP_CLI_SUPPORT YES)

From 90180bfe2e9bd4799bec6a79bfca243012f68100 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 17:56:46 -0400
Subject: [PATCH 192/290] temporarily enable DOXYGEN CI to test README.md fixes

---
 .github/workflows/gh-pages.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index aff5dcdce..f3aec275c 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -1,8 +1,9 @@
 name: Doxygen CI
 
 on:
-  push:
-    branches: [master]
+  [push]
+  # push:
+  #   branches: [master]
 
 jobs:
   build:

From 1ef2e381fcb10e96417f0e07d181f880e5505205 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 17:58:09 -0400
Subject: [PATCH 193/290] replace SVG images in markdown with HTML img tags

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index b56c4f5f4..f166aaf0f 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
 # The Algorithms - C++ # {#mainpage}
-[![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
+[<img src="https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square" alt="contributions welcome"/>](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)
 ![GitHub repo size](https://img.shields.io/github/repo-size/kvedala/C-Plus-Plus?color=red&style=flat-square)
 ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/kvedala/C-Plus-Plus?color=green&style=flat-square)
-![Doxygen CI](https://github.com/kvedala/C-Plus-Plus/workflows/Doxygen%20CI/badge.svg)
-![cpplint](https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg)
-![C/C++ CI](https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg)
+<img src="https://github.com/kvedala/C-Plus-Plus/workflows/Doxygen%20CI/badge.svg" alt="Doxygen CI"/>
+<img src="https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg" alt="cpplint status"/>
+<img src="https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg" alt="C/C++ CI" />
 
 [Documentation](https://kvedala.github.io/C-Plus-Plus)
 

From 9f9325e5f3192e423fc99c0805dde5b0b7a87698 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 18:18:19 -0400
Subject: [PATCH 194/290] install doxygen via brew

---
 .github/workflows/gh-pages.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index f3aec275c..b24c36f3e 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -15,7 +15,8 @@ jobs:
       - name: Install requirements
         run: |
           sudo apt -qq -y update
-          sudo apt -qq install doxygen graphviz ninja-build
+          sudo apt -qq install graphviz ninja-build
+          sudo brew install doxygen
       - name: configure
         run: cmake -G Ninja -B ./build -S .
       - name: build

From 4c3823ada32c54afdd0ad4ab48b141a71be82b0f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 18:25:06 -0400
Subject: [PATCH 195/290] switch doxygen build to macos

---
 .github/workflows/gh-pages.yml | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index b24c36f3e..c548dd05b 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -7,15 +7,14 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
     steps:
       - uses: actions/checkout@master
         with:
           submodules: true
       - name: Install requirements
         run: |
-          sudo apt -qq -y update
-          sudo apt -qq install graphviz ninja-build
+          sudo brew install graphviz ninja-build
           sudo brew install doxygen
       - name: configure
         run: cmake -G Ninja -B ./build -S .

From f2a6b63c53a62ae8d60d38ed93ab954894e97929 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 18:26:29 -0400
Subject: [PATCH 196/290] brew install without sudo

---
 .github/workflows/gh-pages.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index c548dd05b..9749b9b8d 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -14,8 +14,8 @@ jobs:
           submodules: true
       - name: Install requirements
         run: |
-          sudo brew install graphviz ninja-build
-          sudo brew install doxygen
+          brew install graphviz ninja-build
+          brew install doxygen
       - name: configure
         run: cmake -G Ninja -B ./build -S .
       - name: build

From 5b58d7092c2bab4f8db614d81234f9e70dda7589 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 18:29:48 -0400
Subject: [PATCH 197/290] brew uses "ninja" and not "ninja-build"

---
 .github/workflows/gh-pages.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index 9749b9b8d..ed43f44ea 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -14,7 +14,7 @@ jobs:
           submodules: true
       - name: Install requirements
         run: |
-          brew install graphviz ninja-build
+          brew install graphviz ninja
           brew install doxygen
       - name: configure
         run: cmake -G Ninja -B ./build -S .

From e3fbc6bc2c29296a30bffb8896c7fa2c2b7fcff2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 18:34:45 -0400
Subject: [PATCH 198/290] reset README.md file to using non-HTML tags

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index f166aaf0f..b56c4f5f4 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
 # The Algorithms - C++ # {#mainpage}
-[<img src="https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square" alt="contributions welcome"/>](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)
+[![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
 ![GitHub repo size](https://img.shields.io/github/repo-size/kvedala/C-Plus-Plus?color=red&style=flat-square)
 ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/kvedala/C-Plus-Plus?color=green&style=flat-square)
-<img src="https://github.com/kvedala/C-Plus-Plus/workflows/Doxygen%20CI/badge.svg" alt="Doxygen CI"/>
-<img src="https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg" alt="cpplint status"/>
-<img src="https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg" alt="C/C++ CI" />
+![Doxygen CI](https://github.com/kvedala/C-Plus-Plus/workflows/Doxygen%20CI/badge.svg)
+![cpplint](https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg)
+![C/C++ CI](https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg)
 
 [Documentation](https://kvedala.github.io/C-Plus-Plus)
 

From 11bb03f25579c223f848f02a876169c958739bfb Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 18:39:15 -0400
Subject: [PATCH 199/290] reset Doxygen CI to only execute on master branch

---
 .github/workflows/gh-pages.yml | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index ed43f44ea..700d1a3f7 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -1,9 +1,8 @@
 name: Doxygen CI
 
 on:
-  [push]
-  # push:
-  #   branches: [master]
+  push:
+    branches: [master]
 
 jobs:
   build:
@@ -14,8 +13,7 @@ jobs:
           submodules: true
       - name: Install requirements
         run: |
-          brew install graphviz ninja
-          brew install doxygen
+          brew install graphviz ninja doxygen
       - name: configure
         run: cmake -G Ninja -B ./build -S .
       - name: build

From 186c7a2de85adc61cd7d2ae6b83d51ee21616fd1 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 19:37:21 -0400
Subject: [PATCH 200/290] add missing free for dynamic memory allocated

---
 search/binary_search.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/search/binary_search.cpp b/search/binary_search.cpp
index 9933c9816..d8a3a6631 100644
--- a/search/binary_search.cpp
+++ b/search/binary_search.cpp
@@ -30,5 +30,7 @@ int main(int argc, char const* argv[]) {
        std::cout << key << " found at index " << res << std::endl;
     else
        std::cout << key << " not found" << std::endl;
+
+    delete[] a;
     return 0;
 }

From 94f3ffe146f7f2daa4a8c4e8498d587e6ee27876 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 19:37:33 -0400
Subject: [PATCH 201/290] document binary search

---
 search/binary_search.cpp | 56 +++++++++++++++++++++++++++-------------
 1 file changed, 38 insertions(+), 18 deletions(-)

diff --git a/search/binary_search.cpp b/search/binary_search.cpp
index d8a3a6631..66da31d7f 100644
--- a/search/binary_search.cpp
+++ b/search/binary_search.cpp
@@ -1,35 +1,55 @@
+/**
+ * @file
+ * @brief [Binary search
+ * algorithm](https://en.wikipedia.org/wiki/Binary_search_algorithm)
+ */
 #include <iostream>
-// binary_search function
-int binary_search(int a[], int l, int r, int key) {
+
+/** binary_search function
+ * \param [in] a array to sort
+ * \param [in] r right hand limit = \f$n-1\f$
+ * \param [in] key value to find
+ * \returns index if T is found
+ * \return -1 if T is not found
+ */
+int binary_search(int a[], int r, int key) {
+    int l = 0;
+
     while (l <= r) {
-          int m = l + (r - l) / 2;
-          if (key == a[m])
-              return m;
-          else if (key < a[m])
-               r = m - 1;
-          else
-              l = m + 1;
-          }
-          return -1;
-     }
+        int m = l + (r - l) / 2;
+        if (key == a[m])
+            return m;
+        else if (key < a[m])
+            r = m - 1;
+        else
+            l = m + 1;
+    }
+    return -1;
+}
+
+/** main function */
 int main(int argc, char const* argv[]) {
     int n, key;
     std::cout << "Enter size of array: ";
     std::cin >> n;
     std::cout << "Enter array elements: ";
+
     int* a = new int[n];
-// this loop use for store value in Array
+
+    // this loop use for store value in Array
     for (int i = 0; i < n; i++) {
         std::cin >> a[i];
-        }
+    }
+
     std::cout << "Enter search key: ";
     std::cin >> key;
-// this is use for find value in given array
-    int res = binary_search(a, 0, n - 1, key);
+
+    // this is use for find value in given array
+    int res = binary_search(a, n - 1, key);
     if (res != -1)
-       std::cout << key << " found at index " << res << std::endl;
+        std::cout << key << " found at index " << res << std::endl;
     else
-       std::cout << key << " not found" << std::endl;
+        std::cout << key << " not found" << std::endl;
 
     delete[] a;
     return 0;

From 605fa140cc34caa6cc1a9c00c6b40b9a89fc2929 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 19:54:24 -0400
Subject: [PATCH 202/290] free dynamically allocated memory

---
 search/exponential_search.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/search/exponential_search.cpp b/search/exponential_search.cpp
index 5f9e64217..79f09e38b 100644
--- a/search/exponential_search.cpp
+++ b/search/exponential_search.cpp
@@ -59,5 +59,6 @@ int main() {
     assert(struzik_search<int>(sorted_array, 7, 50) == nullptr);
     assert(struzik_search<int>(sorted_array, 7, 7) == sorted_array);
     // TEST CASES
+    delete[] sorted_array;
     return 0;
 }

From 969e916871f3e168506c8968008fded8122e7a74 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 19:54:37 -0400
Subject: [PATCH 203/290] document exponential search

---
 search/exponential_search.cpp | 62 +++++++++++++++++++++++------------
 1 file changed, 41 insertions(+), 21 deletions(-)

diff --git a/search/exponential_search.cpp b/search/exponential_search.cpp
index 79f09e38b..f57cbf96b 100644
--- a/search/exponential_search.cpp
+++ b/search/exponential_search.cpp
@@ -1,20 +1,42 @@
-// Copyright 2020 Divide-et-impera-11
+/**
+ * \file
+ * \brief [Exponential search
+ * algorithm](https://en.wikipedia.org/wiki/Exponential_search)
+ * \copyright 2020 Divide-et-impera-11
+ *
+ * The algorithm try to search the range where the key should be.
+ * If it has been found we do a binary search there.
+ * The range of the search grows by exponential every time.
+ * If the key is larger than the last element of array, the start of
+ * block(block_front) will be equal to the end of block(block_size) and the
+ * algorithm return null ponter, every other cases the algoritm return fom the
+ * loop.
+ */
 #include <cassert>
 #include <cmath>
 #include <iostream>
-#include <string>
+#ifdef _MSC_VER
+#include <string>  // use for MS Visual C++
+#else
+#include <cstring>  // for all other compilers
+#endif
 
-// Binary Search Algorithm(use by struzik algorithm)
-// Time Complexity O(log n) where 'n' is the number of elements
-// Worst Time Complexity O(log n)
-// Best Time Complexity Ω(1)
-// Space Complexity O(1)
-// Auxiliary Space Complexity O(1)
+/** Binary Search Algorithm (used by ::struzik_search)\n
+ * * Time Complexity O(log n) where 'n' is the number of elements
+ * * Worst Time Complexity O(log n)
+ * * Best Time Complexity Ω(1)
+ * * Space Complexity O(1)
+ * * Auxiliary Space Complexity O(1)
+ * \returns pointer to value in the array
+ * \returns `nullptr` if value not found
+ */
 template <class Type>
 inline Type* binary_s(Type* array, size_t size, Type key) {
     int32_t lower_index(0), upper_index(size - 1), middle_index;
+
     while (lower_index <= upper_index) {
         middle_index = std::floor((lower_index + upper_index) / 2);
+
         if (*(array + middle_index) < key)
             lower_index = (middle_index + 1);
         else if (*(array + middle_index) > key)
@@ -22,21 +44,17 @@ inline Type* binary_s(Type* array, size_t size, Type key) {
         else
             return (array + middle_index);
     }
+
     return nullptr;
 }
-// Struzik Search Algorithm(Exponential)
-// Time Complexity O(log i)where i is the position of search key in the list
-// Worst Time Complexity O(log i)
-// Best Time Complexity Ω(1)
-// Space Complexity O(1)
-// Auxiliary Space Complexity O(1)
-/* Tha algorithm try to search the range where the key should be.
-If it has been found we do a binary search there.
-The range of the search grows by exponential every time.
-If the key is larger than the last element of array,
-the start of block(block_front) will be equal to the end of block(block_size)
-and the algorithm return null ponter,
-every other cases the algoritm return fom the loop. */
+
+/** Struzik Search Algorithm(Exponential)
+ * * Time Complexity O(log i) where i is the position of search key in the list
+ * * Worst Time Complexity O(log i)
+ * * Best Time Complexity Ω(1)
+ * * Space Complexity O(1)
+ * * Auxiliary Space Complexity O(1)
+ */
 template <class Type>
 Type* struzik_search(Type* array, size_t size, Type key) {
     uint32_t block_front(0), block_size = size == 0 ? 0 : 1;
@@ -51,6 +69,8 @@ Type* struzik_search(Type* array, size_t size, Type key) {
     }
     return nullptr;
 }
+
+/** Main function */
 int main() {
     // TEST CASES
     int* sorted_array = new int[7]{7, 10, 15, 23, 70, 105, 203};

From d9ffc8aca168cade7093d13501c09b8d616a2df3 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 20:24:44 -0400
Subject: [PATCH 204/290] document hash search

---
 search/hash_search.cpp | 147 ++++++++++++++++++++++++++---------------
 1 file changed, 93 insertions(+), 54 deletions(-)

diff --git a/search/hash_search.cpp b/search/hash_search.cpp
index 94d87b58a..6e4caffc3 100644
--- a/search/hash_search.cpp
+++ b/search/hash_search.cpp
@@ -1,100 +1,139 @@
-// Copyright 2020 Arctic2333
-#include <stdlib.h>
-#include<stdio.h>
-#define MAX 6  // Determines how much data
-# define HASHMAX 5  // Determines the length of the hash table
 /**
-  * Hash Search Algorithm
-  * Best Time Complexity Ω(1)
-  * In this algorithm, we use the method of division and reservation remainder to construct the hash function, 
-  * and use the method of chain address to solve the conflict, that is, we link a chain list after the data, 
-  * and store all the records whose keywords are synonyms in the same linear chain list. */
-int data[MAX] = { 1, 10, 15, 5, 8, 7};  // test data
+ * \file
+ * \brief Hash Search Algorithm - Best Time Complexity Ω(1)
+ *
+ * \copyright 2020 Arctic2333
+ *
+ * In this algorithm, we use the method of division and reservation remainder to
+ * construct the hash function, and use the method of chain address to solve the
+ * conflict, that is, we link a chain list after the data, and store all the
+ * records whose keywords are synonyms in the same linear chain list.
+ *
+ * @warning This program is only for educational purposes. It has serious flaws
+ * in implementation with regards to memory management resulting in large
+ * amounts of memory leaks.
+ * @todo fix the program for memory leaks and better structure in C++ and not C
+ * fashion
+ */
+#include <cstdlib>
+#include <iostream>
+
+#define MAX 6      ///< Determines how much data
+#define HASHMAX 5  ///< Determines the length of the hash table
+
+int data[MAX] = {1, 10, 15, 5, 8, 7};  //!< test data
+
+/**
+ * a one-way linked list
+ */
 typedef struct list {
-    int key;
-    struct list * next;
-}
-node, * link;
-node hashtab[HASHMAX];
-int counter = 1;
-/* int h(int key)
+    int key;            //!< key value for node
+    struct list* next;  //!< pointer to next link in the chain
+} node,                 /**< define node as one item list */
+    *link;              ///< pointer to nodes
+
+node hashtab[HASHMAX];  ///< array of nodes
+
+// int counter = 1;
+
+/**
  * Mode of hash detection :
- * Division method */
-int h(int key) {
-    return key % HASHMAX;
-}
-/* void create_list(int key)
+ * Division method
+ * \param [in] key to hash
+ * \returns hash value for `key`
+ */
+int h(int key) { return key % HASHMAX; }
+
+/**
  * The same after the remainder will be added after the same hash header
  * To avoid conflict, zipper method is used
- * Insert elements into the linked list in the header */
+ * Insert elements into the linked list in the header
+ * \param [in] key key to add to list
+ * \warning dynamic memory allocated to `n` never gets freed.
+ * \todo fix memory leak
+ */
 void create_list(int key) {  // Construct hash table
     link p, n;
     int index;
-    n = (link) malloc(sizeof(node));
-    n -> key = key;
-    n -> next = NULL;
+    n = (link)malloc(sizeof(node));
+    n->key = key;
+    n->next = NULL;
     index = h(key);
     p = hashtab[index].next;
     if (p != NULL) {
-        n -> next = p;
+        n->next = p;
         hashtab[index].next = n;
     } else {
-        hashtab[index].next = n; }
+        hashtab[index].next = n;
+    }
 }
-/* int hash_search(int key)
- * Input the key to be searched, and get the hash header position through the H (int key) function,
- * then one-dimensional linear search.
- * If found @return element depth and number of searches
- * If not found @return -1 */
-int hash_search(int key) {  // Hash lookup function
+
+/**
+ * Input the key to be searched, and get the hash header position through the H
+ * (int key) function, then one-dimensional linear search. If found @return
+ * element depth and number of searches If not found @return -1
+ */
+int hash_search(int key, int* counter) {  // Hash lookup function
     link pointer;
     int index;
-    counter = 0;
+
+    *counter = 0;
     index = h(key);
     pointer = hashtab[index].next;
-    printf("data[%d]:", index);
+
+    std::cout << "data[" << index << "]:";
+
     while (pointer != NULL) {
-        counter++;
-        printf("data[%d]:", pointer -> key);
-        if (pointer -> key == key)
+        counter[0]++;
+        std::cout << "data[" << pointer->key << "]:";
+        if (pointer->key == key)
             return 1;
         else
-            pointer = pointer -> next;
+            pointer = pointer->next;
     }
+
     return 0;
 }
+
+/** main function */
 int main() {
     link p;
-    int key, index, i;  // Key is the value to be found
+    int key, index, i, counter;  // Key is the value to be found
     index = 0;
+
     // You can write the input mode here
     while (index < MAX) {  // Construct hash table
         create_list(data[index]);
         index++;
     }
+
     for (i = 0; i < HASHMAX; i++) {  // Output hash table
-        printf("hashtab [%d]", i);
-        printf("\n");
+        std::cout << "hashtab [" << i << "]\n";
+
         p = hashtab[i].next;
+
         while (p != NULL) {
-            printf("please int key:");
-            if (p -> key > 0)
-                printf("[%d]", p -> key);
-            p = p -> next;
+            std::cout << "please int key:";
+            if (p->key > 0)
+                std::cout << "[" << p->key << "]";
+            p = p->next;
         }
-        printf("\n");
+        std::cout << std::endl;
     }
+
     while (key != -1) {
         // You can write the input mode here
         // test key = 10
         key = 10;
-        if (hash_search(key))
-            printf("search time = %d\n", counter);
+        if (hash_search(key, &counter))
+            std::cout << "search time = " << counter << std::endl;
         else
-            printf("no found!\n");
+            std::cout << "no found!\n";
         key = -1;  // Exit test
-        /* The test sample is returned as: data[0]:data[5]:data[15]:data[10]:search time = 3
-         * The search is successful. There are 10 in this set of data */
+        /* The test sample is returned as:
+         * data[0]:data[5]:data[15]:data[10]:search time = 3 The search is
+         * successful. There are 10 in this set of data */
     }
+
     return 0;
 }

From 7fd12991f74280018724920d73761ef6328b51b8 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 20:31:41 -0400
Subject: [PATCH 205/290]  document interpolation search

---
 search/interpolation_search.cpp | 89 +++++++++++++++++++++------------
 1 file changed, 57 insertions(+), 32 deletions(-)

diff --git a/search/interpolation_search.cpp b/search/interpolation_search.cpp
index afa9e7c50..e12dbd157 100644
--- a/search/interpolation_search.cpp
+++ b/search/interpolation_search.cpp
@@ -1,36 +1,61 @@
-#include<iostream>
+/**
+ * \file
+ * \brief [Interpolation
+ * search](https://en.wikipedia.org/wiki/Interpolation_search) algorithm
+ */
+#include <iostream>
 
-// function to search the value in an array using interpolation search
-int search(int arr[], int value, int len) {
-        int low = 0, high, mid;
-        high = len-1;
-        while (arr[low] <= value && arr[high] >= value) {
-            mid = (low + ((value-arr[low])*(high-low)) / (arr[high]-arr[low]));
-            if (arr[mid] > value)
-                     high = mid-1;
-            else if (arr[mid] < value)
-                     low = mid+1;
-            else
-                     return mid;
-            }
-        if (arr[low] == value)
-                return low;
-        return 0;
+/** function to search the value in an array using interpolation search
+ * \param [in] arr array to search in
+ * \param [in] value value to search for
+ * \param [in] len length of array
+ * \returns index where the value is found
+ * \returns 0 if not found
+ */
+int interpolation_search(int arr[], int value, int len) {
+    int low = 0, high, mid;
+    high = len - 1;
+
+    while (arr[low] <= value && arr[high] >= value) {
+        mid = (low +
+               ((value - arr[low]) * (high - low)) / (arr[high] - arr[low]));
+        if (arr[mid] > value)
+            high = mid - 1;
+        else if (arr[mid] < value)
+            low = mid + 1;
+        else
+            return mid;
+    }
+
+    if (arr[low] == value)
+        return low;
+
+    return 0;
 }
 
+/** main function */
 int main() {
-        int n, value, array[100], re;
-        std::cout << "Enter the size of array(less than 100) : ";
-        std::cin >> n;
-        std::cout << "array in ascending (increasing) order : " << std::endl;
-        for (int i=0; i < n; i++)
-                std::cin >> array[i];
-        std::cout << "Enter the value you want to search : ";
-        std::cin >> value;
-        re = search(array, value, n);
-        if (re == 0)
-                std::cout << "Entered value is not in the array" << std::endl;
-        else
-                std::cout << "The value is at the position " << re << std::endl;
-        return 0;
-        }
+    int n, value, re;
+
+    std::cout << "Enter the size of array(less than 100) : ";
+    std::cin >> n;
+
+    int *array = new int[n];
+
+    std::cout << "array in ascending (increasing) order : " << std::endl;
+
+    for (int i = 0; i < n; i++) std::cin >> array[i];
+
+    std::cout << "Enter the value you want to search : ";
+    std::cin >> value;
+
+    re = interpolation_search(array, value, n);
+
+    if (re == 0)
+        std::cout << "Entered value is not in the array" << std::endl;
+    else
+        std::cout << "The value is at the position " << re << std::endl;
+
+    delete[] array;
+    return 0;
+}

From 85020eea5faf69972a8e685b7b4be80abec052c7 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 20:33:25 -0400
Subject: [PATCH 206/290] change error return value for function

---
 search/interpolation_search.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/search/interpolation_search.cpp b/search/interpolation_search.cpp
index e12dbd157..4339dc366 100644
--- a/search/interpolation_search.cpp
+++ b/search/interpolation_search.cpp
@@ -30,7 +30,7 @@ int interpolation_search(int arr[], int value, int len) {
     if (arr[low] == value)
         return low;
 
-    return 0;
+    return -1;
 }
 
 /** main function */
@@ -51,7 +51,7 @@ int main() {
 
     re = interpolation_search(array, value, n);
 
-    if (re == 0)
+    if (re == -1)
         std::cout << "Entered value is not in the array" << std::endl;
     else
         std::cout << "The value is at the position " << re << std::endl;

From 4bc199ff1d9eda8faeb298c88c7c9dfeeb22f9b9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 20:35:12 -0400
Subject: [PATCH 207/290] document interpolation search 2

---
 search/interpolation_search2.cpp | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/search/interpolation_search2.cpp b/search/interpolation_search2.cpp
index 0e6d3b79d..93fa6cd83 100644
--- a/search/interpolation_search2.cpp
+++ b/search/interpolation_search2.cpp
@@ -1,4 +1,17 @@
+/**
+ * \file
+ * \brief [Interpolation
+ * search](https://en.wikipedia.org/wiki/Interpolation_search) algorithm
+ */
 #include <iostream>
+
+/** function to search the value in an array using interpolation search
+ * \param [in] arr array to search in
+ * \param [in] value value to search for
+ * \param [in] len length of array
+ * \returns index where the value is found
+ * \returns -1 if not found
+ */
 int InterpolationSearch(int A[], int n, int x) {
     int low = 0;
     int high = n - 1;
@@ -11,18 +24,21 @@ int InterpolationSearch(int A[], int n, int x) {
         else
             low = mid + 1;  // x lies after mid
     }
+
     return -1;
 }
 
+/** main function */
 int main() {
     int A[] = {2, 4, 5, 7, 13, 14, 15, 23};
     int x = 17;
-    int index = InterpolationSearch(
-        A, 8, x);  // passed array A inside the InterpolationSearch function
-    if (index != -1)
-        std::cout << "Number " << x << " is at " << index;
+
+    ///< passed array A inside the InterpolationSearch function
+    int index = InterpolationSearch(A, 8, x);
+    if (index < 0)
+        std::cout << "Number " << x << " not found" << std::endl;
     else
-        std::cout << "Number " << x << " not found";
+        std::cout << "Number " << x << " is at " << index << std::endl;
 }
 
 // randomly set x bcoz array was defined by us , therefore not reasonable for

From 2b57d1ff881b77636b88987978ae38d62741192f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 20:36:44 -0400
Subject: [PATCH 208/290] document jump search

---
 search/jump_search.cpp | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/search/jump_search.cpp b/search/jump_search.cpp
index aa2ee0bdb..f7b100a4e 100644
--- a/search/jump_search.cpp
+++ b/search/jump_search.cpp
@@ -1,9 +1,14 @@
-// C++ program to implement Jump Search
-
+/**
+ * \file
+ * \brief C++ program to implement [Jump
+ * Search](https://en.wikipedia.org/wiki/Jump_search)
+ */
 #include <algorithm>
 #include <cmath>
 #include <iostream>
 
+/** jump search implementation
+ */
 int jumpSearch(int arr[], int x, int n) {
     // Finding block size to be jumped
     int step = std::sqrt(n);
@@ -14,7 +19,8 @@ int jumpSearch(int arr[], int x, int n) {
     while (arr[std::min(step, n) - 1] < x) {
         prev = step;
         step += std::sqrt(n);
-        if (prev >= n) return -1;
+        if (prev >= n)
+            return -1;
     }
 
     // Doing a linear search for x in block
@@ -24,10 +30,12 @@ int jumpSearch(int arr[], int x, int n) {
 
         // If we reached next block or end of
         // array, element is not present.
-        if (prev == std::min(step, n)) return -1;
+        if (prev == std::min(step, n))
+            return -1;
     }
     // If element is found
-    if (arr[prev] == x) return prev;
+    if (arr[prev] == x)
+        return prev;
 
     return -1;
 }

From 5ab43ad039f9aa943e596f6e47d26a36a1fb42a0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 20:41:31 -0400
Subject: [PATCH 209/290] document linear search

---
 search/linear_search.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/search/linear_search.cpp b/search/linear_search.cpp
index 8849549e5..142506951 100644
--- a/search/linear_search.cpp
+++ b/search/linear_search.cpp
@@ -1,5 +1,18 @@
+/**
+ * \file
+ * \brief [Linear search
+ * algorithm](https://en.wikipedia.org/wiki/Linear_search)
+ */
 #include <iostream>
 
+/**
+ * Algorithm implementation
+ * \param [in] array array to search in
+ * \param [in] size length of array
+ * \param [in] key key value to search for
+ * \returns index where the key-value occurs in the array
+ * \returns -1 if key-value not found
+ */
 int LinearSearch(int *array, int size, int key) {
     for (int i = 0; i < size; ++i) {
         if (array[i] == key) {
@@ -10,6 +23,7 @@ int LinearSearch(int *array, int size, int key) {
     return -1;
 }
 
+/** main function */
 int main() {
     int size;
     std::cout << "\nEnter the size of the Array : ";

From 8291db4f9fb6cf119f75248c795cf56540cee3e2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 21:06:53 -0400
Subject: [PATCH 210/290] attempted to document median search

---
 search/median_search.cpp | 59 +++++++++++++++++++++++++++-------------
 1 file changed, 40 insertions(+), 19 deletions(-)

diff --git a/search/median_search.cpp b/search/median_search.cpp
index fa8ef3826..2134a0dbe 100644
--- a/search/median_search.cpp
+++ b/search/median_search.cpp
@@ -1,18 +1,21 @@
+/**
+ * \file
+ * \brief [Median search](https://en.wikipedia.org/wiki/Median_search) algorithm
+ * \warning This core is erroneous and gives invorrect answers. Tested using
+ * cases from [here](https://brilliant.org/wiki/median-finding-algorithm/)
+ * \ingroup median search
+ * \{
+ */
 #include <algorithm>
-#include <cmath>
-#include <deque>
 #include <iostream>
-#include <iterator>
-#include <stack>
 #include <vector>
 
-std::vector<int> v;
-std::vector<int> s1;
-std::vector<int> s2;
-std::vector<int> s3;
-
+/**
+ * @todo add documentation
+ */
 template <class X>
-void comp(X x) {
+void comp(X x, std::vector<int> &s1, std::vector<int> &s2,
+          std::vector<int> &s3) {
     if (s1.size() >= x && s1.size() + s2.size() < x) {
         std::cout << s2[0] << " is the " << x + 1 << "th element from front";
     } else if (s1.size() > x) {
@@ -26,17 +29,32 @@ void comp(X x) {
         std::cout << x + 1 << " is invalid location";
     }
 }
+
+#define MAX_NUM 20  ///< maximum number of values to sort from
+
+/**
+ * Main function
+ */
 int main() {
-    for (int i = 0; i < 1000; i++) {
-        v.push_back(std::rand() % 1000);
-    }
-    for (int r : v) {
-        std::cout << r << " ";
-    }
-    int median = std::rand() % 1000;
+    std::vector<int> v{25, 21, 98, 100, 76, 22, 43, 60, 89, 87};
+    std::vector<int> s1;
+    std::vector<int> s2;
+    std::vector<int> s3;
+
+    // creates an array of random numbers
+    // for (int i = 0; i < MAX_NUM; i++) {
+    //     int r = std::rand() % 1000;
+    //     v.push_back(r);
+    //     std::cout << r << " ";
+    // }
+    for (int r : v) std::cout << r << " ";
+
+    int median = std::rand() % 1000;  // initialize to a random numnber
+
     std::cout << "\nmedian=" << median << std::endl;
     int avg1, avg2, avg3, sum1 = 0, sum2 = 0, sum3 = 0;
-    for (int i = 0; i < 1000; i++) {
+
+    for (int i = 0; i < v.size(); i++) {  // iterate through all numbers
         if (v.back() == v[median]) {
             avg1 = sum1 + v.back();
             s2.push_back(v.back());
@@ -49,9 +67,12 @@ int main() {
         }
         v.pop_back();
     }
+
     int x;
     std::cout << "enter the no. to be searched form begining:- ";
     std::cin >> x;
-    comp(x - 1);
+    comp(x - 1, s1, s2, s3);
+
     return 0;
 }
+/// }

From ecddfd2704b156886e159bd92c619eb53a0f130b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 21:30:42 -0400
Subject: [PATCH 211/290] use pointers instead

---
 search/median_search.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/search/median_search.cpp b/search/median_search.cpp
index 2134a0dbe..7379cad26 100644
--- a/search/median_search.cpp
+++ b/search/median_search.cpp
@@ -14,16 +14,16 @@
  * @todo add documentation
  */
 template <class X>
-void comp(X x, std::vector<int> &s1, std::vector<int> &s2,
-          std::vector<int> &s3) {
-    if (s1.size() >= x && s1.size() + s2.size() < x) {
-        std::cout << s2[0] << " is the " << x + 1 << "th element from front";
-    } else if (s1.size() > x) {
-        std::sort(s1.begin(), s1.end());
-        std::cout << s1[x] << " is the " << x + 1 << "th element from front";
-    } else if (s1.size() + s2.size() <= x && s3.size() > x) {
-        std::sort(s3.begin(), s3.end());
-        std::cout << s3[x - s1.size() - s2.size()] << " is the " << x + 1
+void comp(X x, std::vector<int> *s1, std::vector<int> *s2,
+          std::vector<int> *s3) {
+    if (s1->size() >= x && s1->size() + s2->size() < x) {
+        std::cout << (*s2)[0] << " is the " << x + 1 << "th element from front";
+    } else if (s1->size() > x) {
+        std::sort(s1->begin(), s1->end());
+        std::cout << (*s1)[x] << " is the " << x + 1 << "th element from front";
+    } else if (s1->size() + s2->size() <= x && s3->size() > x) {
+        std::sort(s3->begin(), s3->end());
+        std::cout << (*s3)[x - s1->size() - s2->size()] << " is the " << x + 1
                   << "th element from front";
     } else {
         std::cout << x + 1 << " is invalid location";
@@ -71,7 +71,7 @@ int main() {
     int x;
     std::cout << "enter the no. to be searched form begining:- ";
     std::cin >> x;
-    comp(x - 1, s1, s2, s3);
+    comp(x - 1, &s1, &s2, &s3);
 
     return 0;
 }

From 9dc580c045de9da759698d519ab86aba4b81e05b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 21:35:28 -0400
Subject: [PATCH 212/290] rename to more meaningful text_search

---
 search/{searching.cpp => text_search.cpp} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename search/{searching.cpp => text_search.cpp} (100%)

diff --git a/search/searching.cpp b/search/text_search.cpp
similarity index 100%
rename from search/searching.cpp
rename to search/text_search.cpp

From a3c1f04b31ce57d89cf02ebfe743fc37ed01078f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 21:36:01 -0400
Subject: [PATCH 213/290] replace platform specific system("pause")

---
 search/text_search.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/search/text_search.cpp b/search/text_search.cpp
index d01619738..903442fc4 100644
--- a/search/text_search.cpp
+++ b/search/text_search.cpp
@@ -28,7 +28,7 @@ int main() {
                           << paragraph.find(word) << std::endl
                           << std::endl;
             }
-            system("pause");
+            std::cin.get();
         }
     }
 }

From b122d659c326a58ff9c305e544181855e7f47fad Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 21:36:11 -0400
Subject: [PATCH 214/290] document text_search

---
 search/text_search.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/search/text_search.cpp b/search/text_search.cpp
index 903442fc4..ee66a506a 100644
--- a/search/text_search.cpp
+++ b/search/text_search.cpp
@@ -1,9 +1,17 @@
+/**
+ * \file
+ * \brief Search for words in a long textual paragraph.
+ */
 #include <cstdlib>
 #include <iostream>
-#include <string>
-
-char paragraph;
+#ifdef _MSC_VER
+#include <string>  // required for MS Visual C++
+#else
+#include <cstring>
+#endif
 
+/** Main function
+ */
 int main() {
     std::string paragraph;
     std::cout << "Please enter your paragraph: \n";

From 5698363bd7814048975ebeb7543535e184bb5043 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 21:46:18 -0400
Subject: [PATCH 215/290] reformat documentation

---
 search/ternary_search.cpp | 67 ++++++++++++++++++++++++++-------------
 1 file changed, 45 insertions(+), 22 deletions(-)

diff --git a/search/ternary_search.cpp b/search/ternary_search.cpp
index 4d1918d48..73b89da7a 100644
--- a/search/ternary_search.cpp
+++ b/search/ternary_search.cpp
@@ -1,49 +1,57 @@
-/*
+/**
+ * \file
+ * \brief [Ternary search](https://en.wikipedia.org/wiki/Ternary_search)
+ * algorithm
+ *
  * This is a divide and conquer algorithm.
  * It does this by dividing the search space by 3 parts and
  * using its property (usually monotonic property) to find
  * the desired index.
  *
- * Time Complexity : O(log3 n)
- * Space Complexity : O(1) (without the array)
+ * * Time Complexity : O(log3 n)
+ * * Space Complexity : O(1) (without the array)
  */
 
 #include <iostream>
 
-/*
+/**
  * The absolutePrecision can be modified to fit preference but
  * it is recommended to not go lower than 10 due to errors that
  * may occur.
- *
+ */
+#define absolutePrecision 10
+/**
  * The value of _target should be decided or can be decided later
  * by using the variable of the function.
  */
-
 #define _target 10
-#define absolutePrecision 10
-#define MAX 10000000
 
-int N = 21;
-int A[MAX] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 10};
+#define MAX 10000000  ///< Maximum length of array
 
-/*
+/**
  * get_input function is to receive input from standard IO
+ * @todo @christianbender Get input from STDIO or write input to memory as done
+ * above.
  */
-void get_input() {
-    // TODO(christianbender): Get input from STDIO or write input to memory as
-    // done above.
-}
+void get_input() {}
 
-/*
+/**
  * This is the iterative method of the ternary search which returns the index of
  * the element.
+ * \param[in] left lower interval limit
+ * \param[in] right upper interval limit
+ * \param[in] A array to search in
+ * \param[in] target value to search for
+ * \returns index where the target value was found
+ * \returns -1 if target value not found
  */
 int it_ternary_search(int left, int right, int A[], int target) {
     while (1) {
         if (left < right) {
             if (right - left < absolutePrecision) {
                 for (int i = left; i <= right; i++)
-                    if (A[i] == target) return i;
+                    if (A[i] == target)
+                        return i;
 
                 return -1;
             }
@@ -69,15 +77,22 @@ int it_ternary_search(int left, int right, int A[], int target) {
     }
 }
 
-/*
+/**
  * This is the recursive method of the ternary search which returns the index of
  * the element.
+ * \param[in] left lower interval limit
+ * \param[in] right upper interval limit
+ * \param[in] A array to search in
+ * \param[in] target value to search for
+ * \returns index where the target value was found
+ * \returns -1 if target value not found
  */
 int rec_ternary_search(int left, int right, int A[], int target) {
     if (left < right) {
         if (right - left < absolutePrecision) {
             for (int i = left; i <= right; i++)
-                if (A[i] == target) return i;
+                if (A[i] == target)
+                    return i;
 
             return -1;
         }
@@ -85,8 +100,10 @@ int rec_ternary_search(int left, int right, int A[], int target) {
         int oneThird = (left + right) / 3 + 1;
         int twoThird = (left + right) * 2 / 3 + 1;
 
-        if (A[oneThird] == target) return oneThird;
-        if (A[twoThird] == target) return twoThird;
+        if (A[oneThird] == target)
+            return oneThird;
+        if (A[twoThird] == target)
+            return twoThird;
 
         if (target < A[oneThird])
             return rec_ternary_search(left, oneThird - 1, A, target);
@@ -99,10 +116,13 @@ int rec_ternary_search(int left, int right, int A[], int target) {
     }
 }
 
-/*
+/**
  * ternary_search is a template function
  * You could either use it_ternary_search or rec_ternary_search according to
  * preference.
+ * \param [in] N length of array
+ * \param[in] A array to search in
+ * \param[in] target value to search for
  */
 void ternary_search(int N, int A[], int target) {
     std::cout << it_ternary_search(0, N - 1, A, target) << '\t';
@@ -110,7 +130,10 @@ void ternary_search(int N, int A[], int target) {
     std::cout << std::endl;
 }
 
+/** Main function */
 int main() {
+    int N = 21;
+    int A[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 10};
     get_input();
     ternary_search(N, A, _target);
     return 0;

From a9e160fe26972dd2ed17d8784359d6cf825e670e Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 29 May 2020 01:46:43 +0000
Subject: [PATCH 216/290] updating DIRECTORY.md

---
 DIRECTORY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 51e840ef4..740a61647 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -177,8 +177,8 @@
   * [Jump Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/jump_search.cpp)
   * [Linear Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/linear_search.cpp)
   * [Median Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/median_search.cpp)
-  * [Searching](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/searching.cpp)
   * [Ternary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/ternary_search.cpp)
+  * [Text Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/text_search.cpp)
 
 ## Sorting
   * [Bead Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bead_sort.cpp)

From 68cf8540a1e6c9df1a4e4cb3a4ae29752c2e675e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 22:48:52 -0400
Subject: [PATCH 217/290] delete secant method - it is identical to regula
 falsi

---
 .../secant_method.cpp                         | 37 -------------------
 1 file changed, 37 deletions(-)
 delete mode 100644 computer_oriented_statistical_methods/secant_method.cpp

diff --git a/computer_oriented_statistical_methods/secant_method.cpp b/computer_oriented_statistical_methods/secant_method.cpp
deleted file mode 100644
index c353ef850..000000000
--- a/computer_oriented_statistical_methods/secant_method.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include <cmath>
-#include <iostream>
-
-static float eq(float i) {
-    return (pow(i, 3) - (4 * i) - 9);  // original equation
-}
-
-int main() {
-    float a, b, z, c, m, n;
-    for (int i = 0; i < 100; i++) {
-        z = eq(i);
-        if (z >= 0) {
-            b = i;
-            a = --i;
-            break;
-        }
-    }
-
-    std::cout << "\nFirst initial: " << a;
-    std::cout << "\nSecond initial: " << b;
-    for (int i = 0; i < 100; i++) {
-        float h, d;
-        m = eq(a);
-        n = eq(b);
-
-        c = ((a * n) - (b * m)) / (n - m);
-        a = b;
-        b = c;
-
-        z = eq(c);
-        if (z > 0 && z < 0.09)  // stoping criteria
-            break;
-    }
-
-    std::cout << "\n\nRoot: " << c;
-    return 0;
-}

From 7af2ad1eaaaaecd5a47aaf823c3049bfc8bf1bc9 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 23:04:35 -0400
Subject: [PATCH 218/290] document + improvize root finding algorithms

---
 .../bisection_method.cpp                      | 57 +++++++++++++----
 .../false_position.cpp                        | 62 +++++++++++++++----
 .../newton_raphson_method.cpp                 | 51 +++++++++------
 3 files changed, 128 insertions(+), 42 deletions(-)

diff --git a/computer_oriented_statistical_methods/bisection_method.cpp b/computer_oriented_statistical_methods/bisection_method.cpp
index 089828c9a..c93c529d2 100644
--- a/computer_oriented_statistical_methods/bisection_method.cpp
+++ b/computer_oriented_statistical_methods/bisection_method.cpp
@@ -1,25 +1,60 @@
+/**
+ * \file
+ * \brief Solve the equation \f$f(x)=0\f$ using [bisection
+ * method](https://en.wikipedia.org/wiki/Bisection_method)
+ *
+ * Given two points \f$a\f$ and \f$b\f$ such that \f$f(a)<0\f$ and
+ * \f$f(b)>0\f$, then the \f$(i+1)^\text{th}\f$ approximation is given by: \f[
+ * x_{i+1} = \frac{a_i+b_i}{2}
+ * \f]
+ * For the next iteration, the interval is selected
+ * as: \f$[a,x]\f$ if \f$x>0\f$ or \f$[x,b]\f$ if \f$x<0\f$. The Process is
+ * continued till a close enough approximation is achieved.
+ *
+ * \see newton_raphson_method.cpp, false_position.cpp, secant_method.cpp
+ */
 #include <cmath>
 #include <iostream>
+#include <limits>
 
-static float eq(float i) {
+#define EPSILON \
+    1e-6  // std::numeric_limits<double>::epsilon()  ///< system accuracy limit
+#define MAX_ITERATIONS 50000  ///< Maximum number of iterations to check
+
+/** define \f$f(x)\f$ to find root for
+ */
+static double eq(double i) {
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
-int main() {
-    float a, b, x, z;
+/** get the sign of any given number */
+template <typename T>
+int sgn(T val) {
+    return (T(0) < val) - (val < T(0));
+}
 
-    for (int i = 0; i < 100; i++) {
-        z = eq(i);
-        if (z >= 0) {
-            b = i;
-            a = --i;
+/** main function */
+int main() {
+    double a = -1, b = 1, x, z;
+    int i;
+
+    // loop to find initial intervals a, b
+    for (int i = 0; i < MAX_ITERATIONS; i++) {
+        z = eq(a);
+        x = eq(b);
+        if (sgn(z) == sgn(x)) {  // same signs, increase interval
+            b++;
+            a--;
+        } else {  // if opposite signs, we got our interval
             break;
         }
     }
 
     std::cout << "\nFirst initial: " << a;
     std::cout << "\nSecond initial: " << b;
-    for (int i = 0; i < 100; i++) {
+
+    // start iterations
+    for (i = 0; i < MAX_ITERATIONS; i++) {
         x = (a + b) / 2;
         z = eq(x);
         std::cout << "\n\nz: " << z << "\t[" << a << " , " << b
@@ -31,10 +66,10 @@ int main() {
             b = x;
         }
 
-        if (z > 0 && z < 0.0009)  // stoping criteria
+        if (std::abs(z) < EPSILON)  // stoping criteria
             break;
     }
 
-    std::cout << "\n\nRoot: " << x;
+    std::cout << "\n\nRoot: " << x << "\t\tSteps: " << i << std::endl;
     return 0;
 }
diff --git a/computer_oriented_statistical_methods/false_position.cpp b/computer_oriented_statistical_methods/false_position.cpp
index c5a314508..aebd154bb 100644
--- a/computer_oriented_statistical_methods/false_position.cpp
+++ b/computer_oriented_statistical_methods/false_position.cpp
@@ -1,19 +1,53 @@
+/**
+ * \file
+ * \brief Solve the equation \f$f(x)=0\f$ using [false position
+ * method](https://en.wikipedia.org/wiki/Regula_falsi), also known as the Secant
+ * method
+ *
+ * Given two points \f$a\f$ and \f$b\f$ such that \f$f(a)<0\f$ and
+ * \f$f(b)>0\f$, then the \f$(i+1)^\text{th}\f$ approximation is given by: \f[
+ * x_{i+1} = \frac{a_i\cdot f(b_i) - b_i\cdot f(a_i)}{f(b_i) - f(a_i)}
+ * \f]
+ * For the next iteration, the interval is selected
+ * as: \f$[a,x]\f$ if \f$x>0\f$ or \f$[x,b]\f$ if \f$x<0\f$. The Process is
+ * continued till a close enough approximation is achieved.
+ *
+ * \see newton_raphson_method.cpp, bisection_method.cpp
+ */
 #include <cmath>
 #include <cstdlib>
 #include <iostream>
+#include <limits>
 
-static float eq(float i) {
-    return (pow(i, 3) - (4 * i) - 9);  // origial equation
+#define EPSILON \
+    1e-6  // std::numeric_limits<double>::epsilon()  ///< system accuracy limit
+#define MAX_ITERATIONS 50000  ///< Maximum number of iterations to check
+
+/** define \f$f(x)\f$ to find root for
+ */
+static double eq(double i) {
+    return (std::pow(i, 3) - (4 * i) - 9);  // origial equation
 }
 
+/** get the sign of any given number */
+template <typename T>
+int sgn(T val) {
+    return (T(0) < val) - (val < T(0));
+}
+
+/** main function */
 int main() {
-    float a, b, z, c, m, n;
-    system("clear");
-    for (int i = 0; i < 100; i++) {
-        z = eq(i);
-        if (z >= 0) {
-            b = i;
-            a = --i;
+    double a = -1, b = 1, x, z, m, n, c;
+    int i;
+
+    // loop to find initial intervals a, b
+    for (int i = 0; i < MAX_ITERATIONS; i++) {
+        z = eq(a);
+        x = eq(b);
+        if (sgn(z) == sgn(x)) {  // same signs, increase interval
+            b++;
+            a--;
+        } else {  // if opposite signs, we got our interval
             break;
         }
     }
@@ -21,18 +55,20 @@ int main() {
     std::cout << "\nFirst initial: " << a;
     std::cout << "\nSecond initial: " << b;
 
-    for (int i = 0; i < 100; i++) {
-        float h, d;
+    for (i = 0; i < MAX_ITERATIONS; i++) {
         m = eq(a);
         n = eq(b);
+
         c = ((a * n) - (b * m)) / (n - m);
+
         a = c;
         z = eq(c);
-        if (z > 0 && z < 0.09) {  // stoping criteria
+
+        if (std::abs(z) < EPSILON) {  // stoping criteria
             break;
         }
     }
 
-    std::cout << "\n\nRoot: " << c;
+    std::cout << "\n\nRoot: " << c << "\t\tSteps: " << i << std::endl;
     return 0;
 }
diff --git a/computer_oriented_statistical_methods/newton_raphson_method.cpp b/computer_oriented_statistical_methods/newton_raphson_method.cpp
index 47d276490..318363a39 100644
--- a/computer_oriented_statistical_methods/newton_raphson_method.cpp
+++ b/computer_oriented_statistical_methods/newton_raphson_method.cpp
@@ -1,42 +1,57 @@
+/**
+ * \file
+ * \brief Solve the equation \f$f(x)=0\f$ using [Newton-Raphson
+ * method](https://en.wikipedia.org/wiki/Newton%27s_method)
+ *
+ * The \f$(i+1)^\text{th}\f$ approximation is given by:
+ * \f[
+ * x_{i+1} = x_i - \frac{f(x_i)}{f'(x_i)}
+ * \f]
+ *
+ * \see bisection_method.cpp, false_position.cpp
+ */
 #include <cmath>
+#include <ctime>
 #include <iostream>
+#include <limits>
 
-static float eq(float i) {
+#define EPSILON \
+    1e-6  // std::numeric_limits<double>::epsilon()  ///< system accuracy limit
+#define MAX_ITERATIONS 50000  ///< Maximum number of iterations to check
+
+/** define \f$f(x)\f$ to find root for
+ */
+static double eq(double i) {
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
-static float eq_der(float i) {
+/** define the derivative function \f$f'(x)\f$
+ */
+static double eq_der(double i) {
     return ((3 * std::pow(i, 2)) - 4);  // derivative of equation
 }
 
+/** Main function */
 int main() {
-    float a, b, z, c, m, n;
+    std::srand(std::time(nullptr));  // initialize randomizer
 
-    for (int i = 0; i < 100; i++) {
-        z = eq(i);
-        if (z >= 0) {
-            b = i;
-            a = --i;
-            break;
-        }
-    }
+    double z, c = std::rand() % 100, m, n;
+    int i;
 
-    std::cout << "\nFirst initial: " << a;
-    std::cout << "\nSecond initial: " << b;
-    c = (a + b) / 2;
+    std::cout << "\nInitial approximation: " << c;
 
-    for (int i = 0; i < 100; i++) {
-        float h;
+    // start iterations
+    for (i = 0; i < MAX_ITERATIONS; i++) {
         m = eq(c);
         n = eq_der(c);
 
         z = c - (m / n);
         c = z;
 
-        if (m > 0 && m < 0.009)  // stoping criteria
+        if (std::abs(m) < EPSILON)  // stoping criteria
             break;
     }
 
-    std::cout << "\n\nRoot: " << z << std::endl;
+    std::cout << "\n\nRoot: " << z << "\t\tSteps: " << i << std::endl;
     return 0;
 }

From bf3ec59ec8e9a8ad3535446118508ab7ee3b6701 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 23:08:24 -0400
Subject: [PATCH 219/290] attempt to document gaussian elimination

---
 .../gaussian_elimination.cpp                      | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/computer_oriented_statistical_methods/gaussian_elimination.cpp b/computer_oriented_statistical_methods/gaussian_elimination.cpp
index 0b8bb693d..60b5648ec 100644
--- a/computer_oriented_statistical_methods/gaussian_elimination.cpp
+++ b/computer_oriented_statistical_methods/gaussian_elimination.cpp
@@ -1,17 +1,26 @@
+/**
+ * \file
+ * \brief [Gaussian elimination
+ * method](https://en.wikipedia.org/wiki/Gaussian_elimination)
+ */
 #include <iostream>
 
+/** Main function */
 int main() {
     int mat_size, i, j, step;
 
     std::cout << "Matrix size: ";
     std::cin >> mat_size;
 
+    // create a 2D matrix by dynamic memory allocation
     double **mat = new double *[mat_size + 1], **x = new double *[mat_size];
     for (i = 0; i <= mat_size; i++) {
         mat[i] = new double[mat_size + 1];
-        if (i < mat_size) x[i] = new double[mat_size + 1];
+        if (i < mat_size)
+            x[i] = new double[mat_size + 1];
     }
 
+    // get the matrix elements from user
     std::cout << std::endl << "Enter value of the matrix: " << std::endl;
     for (i = 0; i < mat_size; i++) {
         for (j = 0; j <= mat_size; j++) {
@@ -20,6 +29,7 @@ int main() {
         }
     }
 
+    // perform Gaussian elimination
     for (step = 0; step < mat_size - 1; step++) {
         for (i = step; i < mat_size - 1; i++) {
             double a = (mat[i + 1][step] / mat[step][step]);
@@ -56,7 +66,8 @@ int main() {
 
     for (i = 0; i <= mat_size; i++) {
         delete[] mat[i];
-        if (i < mat_size) delete[] x[i];
+        if (i < mat_size)
+            delete[] x[i];
     }
     delete[] mat;
     delete[] x;

From 2e0a50b6f52cd158bc9b51d5e5e1336905d8dc25 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 23:11:39 -0400
Subject: [PATCH 220/290] added file brief

---
 .../ordinary_least_squares_regressor.cpp               | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
index 06bd4ea52..de02b27bb 100644
--- a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
+++ b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
@@ -1,11 +1,13 @@
 /**
  * @file
+ * \brief Linear regression example using [Ordinary least
+ * squares](https://en.wikipedia.org/wiki/Ordinary_least_squares)
  *
  * Program that gets the number of data samples and number of features per
  * sample along with output per sample. It applies OLS regression to compute
  * the regression output for additional test data samples.
  */
-#include <iomanip>
+#include <iomanip>  // for print formatting
 #include <iostream>
 #include <vector>
 
@@ -52,7 +54,8 @@ inline bool is_square(std::vector<std::vector<T>> const &A) {
     // Assuming A is square matrix
     size_t N = A.size();
     for (size_t i = 0; i < N; i++)
-        if (A[i].size() != N) return false;
+        if (A[i].size() != N)
+            return false;
     return true;
 }
 
@@ -265,7 +268,8 @@ std::vector<std::vector<float>> get_inverse(
         inverse[row] = inverse[row] / divisor;
         // Row transformations
         for (size_t row2 = 0; row2 < N; row2++) {
-            if (row2 == row) continue;
+            if (row2 == row)
+                continue;
             float factor = temp[row2][row];
             temp[row2] = temp[row2] - factor * temp[row];
             inverse[row2] = inverse[row2] - factor * inverse[row];

From 68392e2aa866f6bb0ac5d1b84f4e37ca3beaaed2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Thu, 28 May 2020 23:22:24 -0400
Subject: [PATCH 221/290] commented doxygen-mainpage, added files-list link

---
 README.md | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index b56c4f5f4..9fb649a0e 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,7 @@
-# The Algorithms - C++ # {#mainpage}
+<!--# DO NOT REMOVE THIS LINE 
+This is for Doxygen to recognize as the index file for the complete documentation
+{#mainpage} -->
+# The Algorithms - C++
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
 ![GitHub repo size](https://img.shields.io/github/repo-size/kvedala/C-Plus-Plus?color=red&style=flat-square)
 ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/kvedala/C-Plus-Plus?color=green&style=flat-square)
@@ -6,9 +9,11 @@
 ![cpplint](https://github.com/kvedala/C-Plus-Plus/workflows/cpplint_modified_files/badge.svg)
 ![C/C++ CI](https://github.com/kvedala/C-Plus-Plus/workflows/C/C++%20CI/badge.svg)
 
-[Documentation](https://kvedala.github.io/C-Plus-Plus)
+[Online Documentation](https://kvedala.github.io/C-Plus-Plus).
 
-### All algorithms implemented in C++ (for education)
+Click on [Files menu](https://kvedala.github.io/C-Plus-Plus/build/html/files.html) to see the list of all the files documented with the code.
+
+### Algorithms implemented in C++ (for education)
 The implementations are for learning purpose. They may be less efficient than the implementation in the standard library.
 
 ### Contribute Guidelines

From 05e544bdce355e62e636c041f6cf028cb4e2d5d7 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Thu, 28 May 2020 23:23:23 -0400
Subject: [PATCH 222/290] corrected files list link path

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9fb649a0e..df1f13b24 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ This is for Doxygen to recognize as the index file for the complete documentatio
 
 [Online Documentation](https://kvedala.github.io/C-Plus-Plus).
 
-Click on [Files menu](https://kvedala.github.io/C-Plus-Plus/build/html/files.html) to see the list of all the files documented with the code.
+Click on [Files menu](https://kvedala.github.io/C-Plus-Plus/html/files.html) to see the list of all the files documented with the code.
 
 ### Algorithms implemented in C++ (for education)
 The implementations are for learning purpose. They may be less efficient than the implementation in the standard library.

From 1ec59ba1dd818627647954e86babcf7fe4b99793 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Thu, 28 May 2020 23:24:53 -0400
Subject: [PATCH 223/290] files-list link correction - this time works :)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index df1f13b24..2cad007c3 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ This is for Doxygen to recognize as the index file for the complete documentatio
 
 [Online Documentation](https://kvedala.github.io/C-Plus-Plus).
 
-Click on [Files menu](https://kvedala.github.io/C-Plus-Plus/html/files.html) to see the list of all the files documented with the code.
+Click on [Files menu](https://kvedala.github.io/C-Plus-Plus/files.html) to see the list of all the files documented with the code.
 
 ### Algorithms implemented in C++ (for education)
 The implementations are for learning purpose. They may be less efficient than the implementation in the standard library.

From 7dfde74ece640aeb21f75ec2e28c7133614a8581 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 23:28:03 -0400
Subject: [PATCH 224/290] document successive approximations

---
 .../successive_approximation.cpp                    | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/computer_oriented_statistical_methods/successive_approximation.cpp b/computer_oriented_statistical_methods/successive_approximation.cpp
index efbcc3bbf..338831464 100644
--- a/computer_oriented_statistical_methods/successive_approximation.cpp
+++ b/computer_oriented_statistical_methods/successive_approximation.cpp
@@ -1,9 +1,22 @@
+/**
+ * \file
+ * \brief Method of successive approximations using [fixed-point
+ * iteration](https://en.wikipedia.org/wiki/Fixed-point_iteration) method
+ */
 #include <cmath>
 #include <iostream>
 
+/** equation 1
+ * \f[f(y) = 3y - \cos y -2\f]
+ */
 static float eq(float y) { return ((3 * y) - (cos(y)) - 2); }
+
+/** equation 2
+ * \f[f(y) = \frac{\cos y}{2} +2\f]
+ */
 static float eqd(float y) { return ((0.5) * ((cos(y)) + 2)); }
 
+/** Main function */
 int main() {
     float y, x1, x2, x3, sum, s, a, f1, f2, gd;
     int i, n;

From 413198bc36c9b758dd43dc6699e52ffeae94c441 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Thu, 28 May 2020 23:30:10 -0400
Subject: [PATCH 225/290] cleaner equation

---
 .../successive_approximation.cpp                            | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/computer_oriented_statistical_methods/successive_approximation.cpp b/computer_oriented_statistical_methods/successive_approximation.cpp
index 338831464..351382f24 100644
--- a/computer_oriented_statistical_methods/successive_approximation.cpp
+++ b/computer_oriented_statistical_methods/successive_approximation.cpp
@@ -9,12 +9,12 @@
 /** equation 1
  * \f[f(y) = 3y - \cos y -2\f]
  */
-static float eq(float y) { return ((3 * y) - (cos(y)) - 2); }
+static float eq(float y) { return (3 * y) - cos(y) - 2; }
 
 /** equation 2
- * \f[f(y) = \frac{\cos y}{2} +2\f]
+ * \f[f(y) = \frac{\cos y+2}{2}\f]
  */
-static float eqd(float y) { return ((0.5) * ((cos(y)) + 2)); }
+static float eqd(float y) { return 0.5 * (cos(y) + 2); }
 
 /** Main function */
 int main() {

From 1afdaa24b6f739bba79004d1226391ccc937cd74 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 29 May 2020 03:36:31 +0000
Subject: [PATCH 226/290] updating DIRECTORY.md

---
 DIRECTORY.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 740a61647..189d6041b 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -15,7 +15,6 @@
   * [Gaussian Elimination](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/gaussian_elimination.cpp)
   * [Newton Raphson Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/newton_raphson_method.cpp)
   * [Ordinary Least Squares Regressor](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp)
-  * [Secant Method](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/secant_method.cpp)
   * [Successive Approximation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/successive_approximation.cpp)
 
 ## Data Structure

From 8621a1db73398891c502f96ad0a3ac2dbcf0b5c5 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 29 May 2020 07:53:46 -0400
Subject: [PATCH 227/290] documented kmp string search

---
 strings/knuth_morris_pratt.cpp | 120 ++++++++++++++++++++-------------
 1 file changed, 72 insertions(+), 48 deletions(-)

diff --git a/strings/knuth_morris_pratt.cpp b/strings/knuth_morris_pratt.cpp
index f6f1169d3..b83cab966 100644
--- a/strings/knuth_morris_pratt.cpp
+++ b/strings/knuth_morris_pratt.cpp
@@ -1,64 +1,88 @@
-/*
-    The Knuth-Morris-Pratt Algorithm for finding a pattern within a piece of text
-    with complexity O(n + m)
-    1) Preprocess pattern to identify any suffixes that are identical to prefixes
-        This tells us where to continue from if we get a mismatch between a character in our pattern
-        and the text.
-    2) Step through the text one character at a time and compare it to a character in the pattern
-        updating our location within the pattern if necessary
-*/
+/**
+ * \file
+ * \brief The [Knuth-Morris-Pratt
+ * Algorithm](https://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm) for
+ * finding a pattern within a piece of text with complexity O(n + m)
+ *
+ * 1. Preprocess pattern to identify any suffixes that are identical to
+ * prefixes. This tells us where to continue from if we get a mismatch between a
+ * character in our pattern and the text.
+ * 2. Step through the text one character at a time and compare it to a
+ * character in the pattern updating our location within the pattern if
+ * necessary
+ */
 
-#include<iostream>
-#include<vector>
-#include<string>
-using namespace std;
-vector<int> getFailureArray(string pattern){
-    int pattern_length=pattern.size();
-    vector<int>failure(pattern_length+1);
-    failure[0]=-1;
-    int j=-1;
-    for(int i=0; i<pattern_length; i++){
-        while(j!=-1&&pattern[j]!=pattern[i]){
-            j=failure[j];
+#include <iostream>
+#ifdef _MSC_VER
+#include <string>  // use this for MS Visucal C++
+#else
+#include <cstring>
+#endif
+#include <vector>
+
+/**
+ * Generate the partial match table aka failure function for a pattern to
+ * search.
+ * \param[in] pattern text for which to create the partial match table
+ * \returns the partial match table as a vector array
+ */
+std::vector<int> getFailureArray(const std::string &pattern) {
+    int pattern_length = pattern.size();
+    std::vector<int> failure(pattern_length + 1);
+    failure[0] = -1;
+    int j = -1;
+
+    for (int i = 0; i < pattern_length; i++) {
+        while (j != -1 && pattern[j] != pattern[i]) {
+            j = failure[j];
         }
         j++;
-        failure[i+1]=j;
+        failure[i + 1] = j;
     }
     return failure;
 }
-bool kmp(string pattern,string text){
-    int text_length=text.size(),pattern_length=pattern.size();
-    vector<int>failure=getFailureArray(pattern);
-    int k=0;
-    for(int  j=0; j<text_length; j++){
-        while(k!=-1&&pattern[k]!=text[j]){
-            k=failure[k];
+
+/**
+ * KMP algorithm to find a pattern in a text
+ * \param[in] pattern string pattern to search
+ * \param[in] text text in which to search
+ * \returns `true` if pattern was found
+ * \returns `false` if pattern was not found
+ */
+bool kmp(const std::string &pattern, const std::string &text) {
+    int text_length = text.size(), pattern_length = pattern.size();
+    std::vector<int> failure = getFailureArray(pattern);
+
+    int k = 0;
+    for (int j = 0; j < text_length; j++) {
+        while (k != -1 && pattern[k] != text[j]) {
+            k = failure[k];
         }
         k++;
-        if(k==pattern_length)return true;
+        if (k == pattern_length)
+            return true;
     }
     return false;
 }
 
-int main()
-{   
-   
-    string text="alskfjaldsabc1abc1abc12k23adsfabcabc";
-    string pattern="abc1abc12l";
-    if(kmp(pattern,text)==true){
-        cout<<"Found"<<endl;
+/** Main function */
+int main() {
+    std::string text = "alskfjaldsabc1abc1abc12k23adsfabcabc";
+    std::string pattern = "abc1abc12l";
+
+    if (kmp(pattern, text) == true) {
+        std::cout << "Found" << std::endl;
+    } else {
+        std::cout << "Not Found" << std::endl;
     }
-    else{
-        cout<<"Not Found"<<endl;
-    }
-    text="abcabc";
-    pattern="bca";
-    if(kmp(pattern,text)==true){
-        cout<<"Found"<<endl;
-    }
-    else{
-        cout<<"Not Found"<<endl;
+
+    text = "abcabc";
+    pattern = "bca";
+    if (kmp(pattern, text) == true) {
+        std::cout << "Found" << std::endl;
+    } else {
+        std::cout << "Not Found" << std::endl;
     }
+
     return 0;
 }
-

From fc47effb657776bbafdc10606e6618234ade8060 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 29 May 2020 08:00:58 -0400
Subject: [PATCH 228/290] document brute force string search

---
 strings/brute_force_string_searching.cpp | 89 ++++++++++++------------
 1 file changed, 45 insertions(+), 44 deletions(-)

diff --git a/strings/brute_force_string_searching.cpp b/strings/brute_force_string_searching.cpp
index 3288b36b0..9a2b5327a 100644
--- a/strings/brute_force_string_searching.cpp
+++ b/strings/brute_force_string_searching.cpp
@@ -1,52 +1,53 @@
-#include  <iostream>
-#include  <string>
-#include  <vector>
-
-using std::string;
-
-int brute_force(string text, string pattern);
-std::vector<std::vector<string>> test_set  =   {
-    // {text, pattern, expected output}
-     {"a", "aa", "-1"},
-     {"a", "a", "0"},
-     {"ba", "b", "0"},
-     {"bba", "bb", "0"},
-     {"bbca", "c", "2"},
-     {"ab", "b", "1"}
-};
-
-int main() {
-    for  (size_t i  =  0 ;  i < test_set.size();  i++) {
-        int output  =  brute_force(test_set[i][0],  test_set[i][1]);
-        if (std::to_string(output)  ==  test_set[i][2])
-            std::cout  <<  "success\n";
-        else
-            std::cout  <<  "failure\n";
-    }
-    return 0;
-}
-
-/*
- *@description    Find a pattern in a string by comparing the pattern
- *                to every substring.
- *@param text     Any string that might contain the pattern.
- *@param pattern  String that we are searching for.
- *@return       Index where the pattern starts in the text or
- *                -1 if the pattern was not found.
+/**
+ * @file
+ * @brief          String pattern search - brute force
  */
+#include <iostream>
+#ifdef _MSC_VER
+#include <string>  // use this for MS Visucal C++
+#else
+#include <cstring>
+#endif
+#include <vector>
 
-int brute_force(string text, string pattern) {
-    size_t pat_l  =  pattern.length();
-    size_t txt_l  =  text.length();
-    int index  =  -1;
-    if (pat_l  <=  txt_l) {
-        for  (size_t i = 0;  i < txt_l-pat_l+1; i++) {
-            string s  =  text.substr(i, pat_l);
-            if (s  ==  pattern) {
-                index  =  i;
+/**
+ * Find a pattern in a string by comparing the pattern to every substring.
+ * @param text     Any string that might contain the pattern.
+ * @param pattern  String that we are searching for.
+ * @return         Index where the pattern starts in the text
+ * @return         -1 if the pattern was not found.
+ */
+int brute_force(const std::string &text, const std::string &pattern) {
+    size_t pat_l = pattern.length();
+    size_t txt_l = text.length();
+    int index = -1;
+    if (pat_l <= txt_l) {
+        for (size_t i = 0; i < txt_l - pat_l + 1; i++) {
+            std::string s = text.substr(i, pat_l);
+            if (s == pattern) {
+                index = i;
                 break;
             }
         }
     }
     return index;
 }
+
+/** set of test cases */
+const std::vector<std::vector<std::string>> test_set = {
+    // {text, pattern, expected output}
+    {"a", "aa", "-1"},  {"a", "a", "0"},    {"ba", "b", "0"},
+    {"bba", "bb", "0"}, {"bbca", "c", "2"}, {"ab", "b", "1"}};
+
+/** Main function */
+int main() {
+    for (size_t i = 0; i < test_set.size(); i++) {
+        int output = brute_force(test_set[i][0], test_set[i][1]);
+
+        if (std::to_string(output) == test_set[i][2])
+            std::cout << "success\n";
+        else
+            std::cout << "failure\n";
+    }
+    return 0;
+}

From 26701b38befee0151c124e4e0ae3702e88ed149a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 29 May 2020 08:27:33 -0400
Subject: [PATCH 229/290] document rabin-karp string search

---
 strings/rabin_karp.cpp | 108 ++++++++++++++++++++++++++---------------
 1 file changed, 68 insertions(+), 40 deletions(-)

diff --git a/strings/rabin_karp.cpp b/strings/rabin_karp.cpp
index 62e3691c1..018ff5632 100644
--- a/strings/rabin_karp.cpp
+++ b/strings/rabin_karp.cpp
@@ -1,39 +1,64 @@
-/*
- * file name : rabin_karp.cpp
- * author    : Amit Kumar 
- * Copyright : 2020 , Amit Kumar 
- * version   : 1.0
+/**
+ * \file
+ * \brief The [Rabin-Karp
+ * Algorithm](https://en.wikipedia.org/wiki/Rabin–Karp_algorithm) for finding a
+ * pattern within a piece of text with complexity O(n + m)
  */
-#include<cassert>
-#include<cmath>
-#include<iostream>
-#include<string>
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#ifdef _MSC_VER
+#include <string>  // use this for MS Visucal C++
+#else
+#include <cstring>
+#endif
 
-using std::string;
-using std::pow;
+#define PRIME 5  ///< Prime modulus for hash functions
 
-#define PRIME 5
-
-int64_t create_hash(string s , int n) {
+/**
+ * convert a string to an intger - called as hashing function
+ * \param[in] s source of string to hash
+ * \param[in] n length of substring to hash
+ * \returns hash integer
+ */
+int64_t create_hash(const std::string& s, int n) {
     int64_t result = 0;
-    for ( int i = 0; i < n; ++i ) {
-        result += (int64_t)(s[i] * (int64_t)pow(PRIME , i));
+    for (int i = 0; i < n; ++i) {
+        result += (int64_t)(s[i] * (int64_t)pow(PRIME, i));
     }
     return result;
 }
 
-int64_t recalculate_hash(string s , int old_index ,
-        int new_index , int64_t old_hash , int patLength) {
+/**
+ * re-hash a string using known existing hash
+ * \param[in] s source of string to hash
+ * \param[in] old_index previous index of string
+ * \param[in] new_index new index of string
+ * \param[in] old_hash previous hash of substring
+ * \param[in] patLength length of substring to hash
+ * \returns new hash integer
+ */
+int64_t recalculate_hash(const std::string& s, int old_index, int new_index,
+                         int64_t old_hash, int patLength) {
     int64_t new_hash = old_hash - s[old_index];
     new_hash /= PRIME;
-    new_hash += (int64_t)(s[new_index]*(int64_t)pow(PRIME, patLength-1));
+    new_hash += (int64_t)(s[new_index] * (int64_t)pow(PRIME, patLength - 1));
     return new_hash;
 }
 
-bool check_if_equal(string str1 , string str2 ,
-                    int start1 , int end1 ,
-                    int start2 , int end2) {
-    if (end1-start1 != end2-start2) {
+/**
+ * compare if two sub-strings are equal
+ * \param[in] str1 string pattern to search
+ * \param[in] str2 text in which to search
+ * \param[in] start1,end1 start and end indices for substring in str1
+ * \param[in] start2,end2 start and end indices for substring in str2
+ * \returns `true` if pattern was found
+ * \returns `false` if pattern was not found
+ * @note can this be replaced by std::string::compare?
+ */
+bool check_if_equal(const std::string& str1, const std::string& str2,
+                    int start1, int end1, int start2, int end2) {
+    if (end1 - start1 != end2 - start2) {
         return false;
     }
     while (start1 <= end1 && start2 <= end2) {
@@ -46,33 +71,36 @@ bool check_if_equal(string str1 , string str2 ,
     return true;
 }
 
-/*
- *  @description : search pattern in the given text 
- *  @param : string str
- *  @param : string pat
- *  @return index of first occurrence of pattern or -1 if pattern not found
+/**
+ *  Perform string pattern search using Rabin-Karp algorithm
+ *  @param[in] str string to search in
+ *  @param[in] pat pattern to search for
+ *  @return index of first occurrence of pattern
+ *  @return -1 if pattern not found
  */
 
-int rabin_karp(const string &str , const string& pat) {
-    int64_t pat_hash = create_hash(pat , pat.size());
-    int64_t str_hash = create_hash(str , pat.size());
-    for (int i=0;  i <= str.size()-pat.size(); ++i) {
+int rabin_karp(const std::string& str, const std::string& pat) {
+    int64_t pat_hash = create_hash(pat, pat.size());
+    int64_t str_hash = create_hash(str, pat.size());
+    for (int i = 0; i <= str.size() - pat.size(); ++i) {
         if (pat_hash == str_hash &&
-            check_if_equal(str , pat , i , i+pat.size()-1 , 0 , pat.size()-1)) {
-                return i;
+            check_if_equal(str, pat, i, i + pat.size() - 1, 0,
+                           pat.size() - 1)) {
+            return i;
         }
-        if (i < str.size()-pat.size()) {
+        if (i < str.size() - pat.size()) {
             str_hash =
-                recalculate_hash(str, i, i+pat.size(), str_hash, pat.size());
+                recalculate_hash(str, i, i + pat.size(), str_hash, pat.size());
         }
     }
     return -1;  // return -1 if given pattern not found
 }
 
+/** Main function */
 int main(void) {
-    assert(rabin_karp("helloWorld", "world")    == -1);
-    assert(rabin_karp("helloWorld", "World")    ==  5);
-    assert(rabin_karp("this_is_c++" , "c++")   ==  8);
-    assert(rabin_karp("happy_coding", "happy") ==  0);
+    assert(rabin_karp("helloWorld", "world") == -1);
+    assert(rabin_karp("helloWorld", "World") == 5);
+    assert(rabin_karp("this_is_c++", "c++") == 8);
+    assert(rabin_karp("happy_coding", "happy") == 0);
     return 0;
 }

From 82362529dfb4d9f1d8e14be74388ef6e1f4eee55 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 29 May 2020 08:32:44 -0400
Subject: [PATCH 230/290] fixed mainpage readme

---
 README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 2cad007c3..85ddf1bb9 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
-<!--# DO NOT REMOVE THIS LINE 
+<!-- # DO NOT REMOVE THIS LINE
 This is for Doxygen to recognize as the index file for the complete documentation
-{#mainpage} -->
+{#mainpage}
+-->
 # The Algorithms - C++
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
 ![GitHub repo size](https://img.shields.io/github/repo-size/kvedala/C-Plus-Plus?color=red&style=flat-square)

From a79ce9d2b610ffea591c10a90e6550950cffe7bf Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 29 May 2020 08:42:21 -0400
Subject: [PATCH 231/290] doxygen v1.8.18 will suppress out the #minipage in
 the markdown

---
 README.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 85ddf1bb9..df39ee554 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,5 @@
-<!-- # DO NOT REMOVE THIS LINE
-This is for Doxygen to recognize as the index file for the complete documentation
-{#mainpage}
--->
-# The Algorithms - C++
+# The Algorithms - C++ # {#mainpage}
+
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)&nbsp;
 ![GitHub repo size](https://img.shields.io/github/repo-size/kvedala/C-Plus-Plus?color=red&style=flat-square)
 ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/kvedala/C-Plus-Plus?color=green&style=flat-square)

From 8036cf033f9606596edfd0da2c58006d789abce0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <krishna.vedala@ieee.org>
Date: Fri, 29 May 2020 09:44:08 -0400
Subject: [PATCH 232/290] cpplint correction for header guard style

---
 math/large_number.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/math/large_number.h b/math/large_number.h
index 959622187..c1a3665e4 100644
--- a/math/large_number.h
+++ b/math/large_number.h
@@ -4,8 +4,8 @@
  * numbers.
  */
 
-#ifndef OTHERS_LARGE_NUMBER_H_
-#define OTHERS_LARGE_NUMBER_H_
+#ifndef MATH_LARGE_NUMBER_H_
+#define MATH_LARGE_NUMBER_H_
 #include <algorithm>
 #include <cassert>
 #include <cinttypes>
@@ -284,4 +284,4 @@ class large_number {
         _digits; /**< where individual digits are stored */
 };
 
-#endif  // OTHERS_LARGE_NUMBER_H_
+#endif  // MATH_LARGE_NUMBER_H_

From 29705aca4bb81ee6ce2dd2abe0953203cb2b0cef Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:06:37 -0400
Subject: [PATCH 233/290] github action to auto format source code per cpplint
 standard

---
 .github/workflows/clang-format.yml | 39 ++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 .github/workflows/clang-format.yml

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
new file mode 100644
index 000000000..6a95452e8
--- /dev/null
+++ b/.github/workflows/clang-format.yml
@@ -0,0 +1,39 @@
+name: Code Formatting
+
+on: [push]
+#   push:
+#     branches: [ master ]
+#   pull_request:
+#     branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: requirements
+        run: | 
+          sudo apt -qq -y update
+          sudo apt -qq install clang-format 
+      - uses: actions/checkout@master
+        with:
+          submodules: true
+      - name: Formatter
+        run: |
+          for fname in $(find . -name '*.cpp' -o -name '*.h')
+          do 
+            clang-format --verbose -i --style="$line1 $line2 $line3 $line4" "$fname"
+          done
+        env:
+          line1: "{ BasedOnStyle: Google, UseTab: Never,"
+          line2: "IndentWidth: 4, TabWidth: 4, BreakBeforeBraces: Allman,"
+          line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
+          line4: "ColumnLimit: 80, AccessModifierOffset: -4 }"
+      - name: Commit files
+        run: |
+          cp -rp ./build/html/* . && rm -rf ./build && ls -lah
+          git config --global user.name github-actions
+          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+          git commit -am "formatting source-code for $GITHUB_SHA" ||  true
+          git push
+      

From e459ea26d347140851b2accd8b1fe0d66ac629de Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:07:47 -0400
Subject: [PATCH 234/290] updated setting to add 1 space before `private` and
 `public` keywords

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 6a95452e8..4acf66536 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -27,7 +27,7 @@ jobs:
           line1: "{ BasedOnStyle: Google, UseTab: Never,"
           line2: "IndentWidth: 4, TabWidth: 4, BreakBeforeBraces: Allman,"
           line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
-          line4: "ColumnLimit: 80, AccessModifierOffset: -4 }"
+          line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
       - name: Commit files
         run: |
           cp -rp ./build/html/* . && rm -rf ./build && ls -lah

From adae176d2a235defd055200bc6d327949ba48c46 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:22:51 -0400
Subject: [PATCH 235/290] auto rename files and auto format code

---
 .github/workflows/clang-format.yml | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 4acf66536..e44869528 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -17,23 +17,30 @@ jobs:
       - uses: actions/checkout@master
         with:
           submodules: true
-      - name: Formatter
+      - name: Setup Git Specs
+        run: |
+          git config --global user.name github-actions
+          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+      - name: Filename Formatter
+          for fname in $(find . -name '*.cpp' -o -name '*.h')
+          do 
+            new_fname = tr ' ' '_' $fname
+            new_fname = tr 'A-Z' 'a-z' $fname
+            echo $new_fname
+          done
+          git commit -am "formatting filenames $GITHUB_SHA" ||  true
+      - name: Clang Formatter
         run: |
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
             clang-format --verbose -i --style="$line1 $line2 $line3 $line4" "$fname"
           done
+          git commit -am "formatting source-code for $GITHUB_SHA" ||  true
         env:
           line1: "{ BasedOnStyle: Google, UseTab: Never,"
           line2: "IndentWidth: 4, TabWidth: 4, BreakBeforeBraces: Allman,"
           line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
           line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
-      - name: Commit files
-        run: |
-          cp -rp ./build/html/* . && rm -rf ./build && ls -lah
-          git config --global user.name github-actions
-          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
-          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
-          git commit -am "formatting source-code for $GITHUB_SHA" ||  true
-          git push
-      
+      # -name: Git Push
+      #   run: git push

From 4c282aed0f30a4b2af10bab3f95471cb1f44412a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:24:14 -0400
Subject: [PATCH 236/290] added missing "run" for step

---
 .github/workflows/clang-format.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index e44869528..b4a46ed04 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -23,6 +23,7 @@ jobs:
           git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - name: Filename Formatter
+        run: |
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
             new_fname = tr ' ' '_' $fname

From 8edc022423ad5c45154ff2b835b5bb33f25cd26a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:26:17 -0400
Subject: [PATCH 237/290] corrected asignmemt operation

---
 .github/workflows/clang-format.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index b4a46ed04..cea261622 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,8 +26,8 @@ jobs:
         run: |
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
-            new_fname = tr ' ' '_' $fname
-            new_fname = tr 'A-Z' 'a-z' $fname
+            $new_fname = tr ' ' '_' $fname
+            $new_fname = tr 'A-Z' 'a-z' $new_fname
             echo $new_fname
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 0ea90eb3bd10aae256b01abd431e2b82f963abe6 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:30:55 -0400
Subject: [PATCH 238/290] fixed trim and assign syntax

---
 .github/workflows/clang-format.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index cea261622..6071aef07 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,8 +26,8 @@ jobs:
         run: |
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
-            $new_fname = tr ' ' '_' $fname
-            $new_fname = tr 'A-Z' 'a-z' $new_fname
+            new_fname="$(echo -e "${fname}" | tr ' ' '_')"
+            new_fname="$(echo -e "${new_fname}"tr'A-Z' 'a-z')"
             echo $new_fname
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 1a8cc7ecec9c0ac381685af8d31f2d254b7fd593 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:33:10 -0400
Subject: [PATCH 239/290] added git move for renaming bad filenames

---
 .github/workflows/clang-format.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 6071aef07..0acad3a2d 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -29,6 +29,7 @@ jobs:
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}"tr'A-Z' 'a-z')"
             echo $new_fname
+            git mv $fname $new_fname
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true
       - name: Clang Formatter

From a045cf894f745200accaa8f047a2c560c987c0a4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:34:20 -0400
Subject: [PATCH 240/290] added missing pipe for trim

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 0acad3a2d..1b35cd16b 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -27,7 +27,7 @@ jobs:
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
-            new_fname="$(echo -e "${new_fname}"tr'A-Z' 'a-z')"
+            new_fname="$(echo -e "${new_fname}" | tr'A-Z' 'a-z')"
             echo $new_fname
             git mv $fname $new_fname
           done

From cbcebf30ecb8244129e90b08c6b9e5c2cad7873c Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:35:14 -0400
Subject: [PATCH 241/290] added missing space

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 1b35cd16b..bec69d481 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -27,7 +27,7 @@ jobs:
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
-            new_fname="$(echo -e "${new_fname}" | tr'A-Z' 'a-z')"
+            new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
             echo $new_fname
             git mv $fname $new_fname
           done

From 48bf52907fdc0c15af4fc92e8a61d6e46f804732 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:37:36 -0400
Subject: [PATCH 242/290] use old and new fnames

---
 .github/workflows/clang-format.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index bec69d481..f3940c5b6 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,10 +26,11 @@ jobs:
         run: |
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
+            old_fname="${fname}"
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
             echo $new_fname
-            git mv $fname $new_fname
+            git mv $old_fname $new_fname
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true
       - name: Clang Formatter

From 1d11ab428426480f5cf2c775e7dfe9fd35c1ecd4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:40:45 -0400
Subject: [PATCH 243/290] store old fname using echo

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index f3940c5b6..33eed8c28 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,11 +26,11 @@ jobs:
         run: |
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
-            old_fname="${fname}"
+            old_fname="$(echo -e ${fname})"
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
-            echo $new_fname
-            git mv $old_fname $new_fname
+            echo "${old_fname} --> ${new_fname}"
+            git mv ${old_fname} ${new_fname}
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true
       - name: Clang Formatter

From 93b9bc11473de0706eb450f35c60bca03c10febe Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:43:28 -0400
Subject: [PATCH 244/290] move files only if there is a change in filename

---
 .github/workflows/clang-format.yml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 33eed8c28..db96de16a 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -29,8 +29,11 @@ jobs:
             old_fname="$(echo -e ${fname})"
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
-            echo "${old_fname} --> ${new_fname}"
-            git mv ${old_fname} ${new_fname}
+            if [$old_fname != $new_fname]
+            then
+              echo "${old_fname} --> ${new_fname}"
+              git mv ${old_fname} ${new_fname}
+            fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true
       - name: Clang Formatter

From 493c52f19ad05f491068db3dfd52cd6d876a4a15 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:45:54 -0400
Subject: [PATCH 245/290] put old filenames in quotes

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index db96de16a..5fe5e589d 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -29,10 +29,10 @@ jobs:
             old_fname="$(echo -e ${fname})"
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
-            if [$old_fname != $new_fname]
+            if [ '$old_fname' != '$new_fname' ]
             then
-              echo "${old_fname} --> ${new_fname}"
-              git mv ${old_fname} ${new_fname}
+              echo "'${old_fname}' --> ${new_fname}"
+              git mv '${old_fname}' ${new_fname}
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 45f5bb65d0a78026a7ad7375afdf35293b41e001 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:47:40 -0400
Subject: [PATCH 246/290] use double quote for old filename

---
 .github/workflows/clang-format.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 5fe5e589d..a8ba8a273 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -29,10 +29,10 @@ jobs:
             old_fname="$(echo -e ${fname})"
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
-            if [ '$old_fname' != '$new_fname' ]
+            if [ $old_fname != $new_fname ]
             then
               echo "'${old_fname}' --> ${new_fname}"
-              git mv '${old_fname}' ${new_fname}
+              git mv "${old_fname}" ${new_fname}
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 29c066de048ccbf9f11955be02b8e1ed81c19013 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:50:17 -0400
Subject: [PATCH 247/290] escape double quotes

---
 .github/workflows/clang-format.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index a8ba8a273..1a9d5ccfc 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -31,8 +31,8 @@ jobs:
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
             if [ $old_fname != $new_fname ]
             then
-              echo "'${old_fname}' --> ${new_fname}"
-              git mv "${old_fname}" ${new_fname}
+              echo '"${old_fname}" --> ${new_fname}'
+              git mv \"${old_fname}\" ${new_fname}
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From c0dcc91276e17be5dc55bc1397bafbdae6bce604 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 17:52:50 -0400
Subject: [PATCH 248/290] remove old_fname

---
 .github/workflows/clang-format.yml | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 1a9d5ccfc..50f2169da 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,13 +26,12 @@ jobs:
         run: |
           for fname in $(find . -name '*.cpp' -o -name '*.h')
           do 
-            old_fname="$(echo -e ${fname})"
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
-            if [ $old_fname != $new_fname ]
+            if [ $fname != $new_fname ]
             then
-              echo '"${old_fname}" --> ${new_fname}'
-              git mv \"${old_fname}\" ${new_fname}
+              echo '"${fname}" --> ${new_fname}'
+              git mv "${fname}" ${new_fname}
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 63f13ea50bb03f59ae0057b3fcc0f1342426baa1 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:00:34 -0400
Subject: [PATCH 249/290] try escape characters and echo"

---
 .github/workflows/clang-format.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 50f2169da..fac11f908 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -30,8 +30,8 @@ jobs:
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
             if [ $fname != $new_fname ]
             then
-              echo '"${fname}" --> ${new_fname}'
-              git mv "${fname}" ${new_fname}
+              echo -e "'"$fname"' --> '"$new_fname"'"
+              git mv "$(echo -e "$fname")" $new_fname
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 18a74bb9a082147720bb30ef3ceb0a23a9ac6dcf Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:06:55 -0400
Subject: [PATCH 250/290] add file-type to find

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index fac11f908..aaea3325f 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -24,14 +24,14 @@ jobs:
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - name: Filename Formatter
         run: |
-          for fname in $(find . -name '*.cpp' -o -name '*.h')
+          for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
             new_fname="$(echo -e "${fname}" | tr ' ' '_')"
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
             if [ $fname != $new_fname ]
             then
-              echo -e "'"$fname"' --> '"$new_fname"'"
-              git mv "$(echo -e "$fname")" $new_fname
+              echo -e "$(echo -e "$fname")" --> '"$new_fname"'"
+              git mv "$fname" $new_fname
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 24f65d859954410e749d4b27a57be776a53d8adb Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:08:48 -0400
Subject: [PATCH 251/290] cleanup echo

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index aaea3325f..5ee612c99 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -30,7 +30,7 @@ jobs:
             new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
             if [ $fname != $new_fname ]
             then
-              echo -e "$(echo -e "$fname")" --> '"$new_fname"'"
+              echo -e $fname" --> "$new_fname
               git mv "$fname" $new_fname
             fi
           done

From bb973aa17d201af39b8e04e9c1911c1e8b393b3a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:11:49 -0400
Subject: [PATCH 252/290] ensure all trim variables are also in quotes

---
 .github/workflows/clang-format.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 5ee612c99..1f9dcb98b 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,8 +26,8 @@ jobs:
         run: |
           for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
-            new_fname="$(echo -e "${fname}" | tr ' ' '_')"
-            new_fname="$(echo -e "${new_fname}" | tr 'A-Z' 'a-z')"
+            new_fname="$(echo -e ${fname} | tr ' ' '_')"
+            new_fname="$(echo -e ${new_fname} | tr 'A-Z' 'a-z')"
             if [ $fname != $new_fname ]
             then
               echo -e $fname" --> "$new_fname

From b5f4637cc7d5419104155576c077438a18ad11b3 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:14:56 -0400
Subject: [PATCH 253/290] try escape -quote again

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 1f9dcb98b..8c56fbed6 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,11 +26,11 @@ jobs:
         run: |
           for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
-            new_fname="$(echo -e ${fname} | tr ' ' '_')"
-            new_fname="$(echo -e ${new_fname} | tr 'A-Z' 'a-z')"
+            new_fname="$(echo -e \"${fname}\" | tr ' ' '_')"
+            new_fname="$(echo -e \"${new_fname}\" | tr 'A-Z' 'a-z')"
             if [ $fname != $new_fname ]
             then
-              echo -e $fname" --> "$new_fname
+              echo -e "\"$fname\" --> $new_fname"
               git mv "$fname" $new_fname
             fi
           done

From 4011a18ff90ea87bd4a988f168bc6614527bd153 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:17:46 -0400
Subject: [PATCH 254/290] remove second escpe quote

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 8c56fbed6..600968b3d 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -27,7 +27,7 @@ jobs:
           for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
             new_fname="$(echo -e \"${fname}\" | tr ' ' '_')"
-            new_fname="$(echo -e \"${new_fname}\" | tr 'A-Z' 'a-z')"
+            new_fname="$(echo -e ${new_fname} | tr 'A-Z' 'a-z')"
             if [ $fname != $new_fname ]
             then
               echo -e "\"$fname\" --> $new_fname"

From b3242230e86118e4670db2b742c5d0ec699fbfc6 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:20:21 -0400
Subject: [PATCH 255/290] use single quote for first check

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 600968b3d..4984aa7cf 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,7 +26,7 @@ jobs:
         run: |
           for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
-            new_fname="$(echo -e \"${fname}\" | tr ' ' '_')"
+            new_fname="$(echo -e '${fname}' | tr ' ' '_')"
             new_fname="$(echo -e ${new_fname} | tr 'A-Z' 'a-z')"
             if [ $fname != $new_fname ]
             then

From 097f0d23eb7ccb94ed8f0b83103a28b2f5e78d2b Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:24:00 -0400
Subject: [PATCH 256/290] use carets instead of quotes

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 4984aa7cf..64e2c3872 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,11 +26,11 @@ jobs:
         run: |
           for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
-            new_fname="$(echo -e '${fname}' | tr ' ' '_')"
-            new_fname="$(echo -e ${new_fname} | tr 'A-Z' 'a-z')"
+            new_fname=`echo -e ${fname} | tr ' ' '_'`
+            new_fname=`echo -e ${new_fname} | tr 'A-Z' 'a-z'`
             if [ $fname != $new_fname ]
             then
-              echo -e "\"$fname\" --> $new_fname"
+              echo -e "$fname --> $new_fname"
               git mv "$fname" $new_fname
             fi
           done

From 43b28808923a36b984347c1457208d4237d2dfae Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:25:38 -0400
Subject: [PATCH 257/290] put variables in brackets

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 64e2c3872..0c5e1d82f 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -28,10 +28,10 @@ jobs:
           do 
             new_fname=`echo -e ${fname} | tr ' ' '_'`
             new_fname=`echo -e ${new_fname} | tr 'A-Z' 'a-z'`
-            if [ $fname != $new_fname ]
+            if [ ${fname} != ${new_fname} ]
             then
-              echo -e "$fname --> $new_fname"
-              git mv "$fname" $new_fname
+              echo -e "${fname} --> ${new_fname}"
+              git mv "${fname}" ${new_fname}
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From b9ed82475e80e528809ea85ffec3925865792876 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:29:50 -0400
Subject: [PATCH 258/290] remove -e from echo

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 0c5e1d82f..2e1bc9fe0 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,11 +26,11 @@ jobs:
         run: |
           for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
-            new_fname=`echo -e ${fname} | tr ' ' '_'`
-            new_fname=`echo -e ${new_fname} | tr 'A-Z' 'a-z'`
+            new_fname=`echo ${fname} | tr ' ' '_'`
+            new_fname=`echo ${new_fname} | tr 'A-Z' 'a-z'`
             if [ ${fname} != ${new_fname} ]
             then
-              echo -e "${fname} --> ${new_fname}"
+              echo "${fname} --> ${new_fname}"
               git mv "${fname}" ${new_fname}
             fi
           done

From 2a674c3d9e136b6aea9b1aa305d4fde4543d563a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:32:03 -0400
Subject: [PATCH 259/290] add debug echos

---
 .github/workflows/clang-format.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 2e1bc9fe0..8f7f4a7b2 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,11 +26,14 @@ jobs:
         run: |
           for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
           do 
+            echo "${fname}"
             new_fname=`echo ${fname} | tr ' ' '_'`
+            echo "      ${new_fname}"
             new_fname=`echo ${new_fname} | tr 'A-Z' 'a-z'`
+            echo "      ${new_fname}"
             if [ ${fname} != ${new_fname} ]
             then
-              echo "${fname} --> ${new_fname}"
+              echo "      ${fname} --> ${new_fname}"
               git mv "${fname}" ${new_fname}
             fi
           done

From 9844d887b0a7f6aba1736d30bb2aa8149cb178e2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:37:32 -0400
Subject: [PATCH 260/290] try print0 flag

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 8f7f4a7b2..90c7ffc82 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -24,7 +24,7 @@ jobs:
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - name: Filename Formatter
         run: |
-          for fname in $(find . -type f -name '*.cpp' -o -name '*.h')
+          for fname in `find . -type f -name '*.cpp' -o -name '*.h' -print0`
           do 
             echo "${fname}"
             new_fname=`echo ${fname} | tr ' ' '_'`

From 1d24b96ad6debfb3db755dfa74903b4fa7f7761e Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:47:20 -0400
Subject: [PATCH 261/290] find command with while instead of for-loop

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 90c7ffc82..b50b8717e 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -24,7 +24,7 @@ jobs:
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - name: Filename Formatter
         run: |
-          for fname in `find . -type f -name '*.cpp' -o -name '*.h' -print0`
+          find . -type f -name '*.cpp' -o -name '*.h' -print0 | while read -d $'\0' fname
           do 
             echo "${fname}"
             new_fname=`echo ${fname} | tr ' ' '_'`

From 0e130658b570f9e5d09df2c8da8520b0c70128e0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:52:01 -0400
Subject: [PATCH 262/290] find command using IFS instead

---
 .github/workflows/clang-format.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index b50b8717e..44260450a 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -24,7 +24,8 @@ jobs:
           git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - name: Filename Formatter
         run: |
-          find . -type f -name '*.cpp' -o -name '*.h' -print0 | while read -d $'\0' fname
+          IFS=$'\n'
+          for fname in `find . -type f -name '*.cpp' -o -name '*.h'`
           do 
             echo "${fname}"
             new_fname=`echo ${fname} | tr ' ' '_'`

From 65dbaf7c693988d9e1ce7821cc3d93363af8a353 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 18:55:36 -0400
Subject: [PATCH 263/290] :tada: IFS fix worked - escaped quotes for git mv

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 44260450a..d2702bf3a 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -35,7 +35,7 @@ jobs:
             if [ ${fname} != ${new_fname} ]
             then
               echo "      ${fname} --> ${new_fname}"
-              git mv "${fname}" ${new_fname}
+              git mv \"${fname}\" ${new_fname}
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 9643f75e0f7968f1eec91f9a4d865b6c8dbd7371 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 19:04:14 -0400
Subject: [PATCH 264/290] protetc each word in git mv ..

---
 .github/workflows/clang-format.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index d2702bf3a..e6d8dee9a 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -32,10 +32,12 @@ jobs:
             echo "      ${new_fname}"
             new_fname=`echo ${new_fname} | tr 'A-Z' 'a-z'`
             echo "      ${new_fname}"
+            new_fname=`echo ${new_fname} | tr '-' '_'`
+            echo "      ${new_fname}"
             if [ ${fname} != ${new_fname} ]
             then
               echo "      ${fname} --> ${new_fname}"
-              git mv \"${fname}\" ${new_fname}
+              git "mv" "${fname}" ${new_fname}
             fi
           done
           git commit -am "formatting filenames $GITHUB_SHA" ||  true

From 7b6932cd6ed490299b3b0a16d1d153e86c10e58f Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 19:08:43 -0400
Subject: [PATCH 265/290] filename exists in lower cases - renamed

---
 data_structure/{Queue Using Array.cpp => Queue Using Array2.cpp} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename data_structure/{Queue Using Array.cpp => Queue Using Array2.cpp} (100%)

diff --git a/data_structure/Queue Using Array.cpp b/data_structure/Queue Using Array2.cpp
similarity index 100%
rename from data_structure/Queue Using Array.cpp
rename to data_structure/Queue Using Array2.cpp

From e7bc4e26192fbd948bb73e810f2ab7edc63c53c3 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 19:23:01 -0400
Subject: [PATCH 266/290] :tada: git push enabled

---
 .github/workflows/clang-format.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index e6d8dee9a..3fb7374e6 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -53,5 +53,5 @@ jobs:
           line2: "IndentWidth: 4, TabWidth: 4, BreakBeforeBraces: Allman,"
           line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
           line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
-      # -name: Git Push
-      #   run: git push
+      - name: Git Push
+        run: git push

From fd394fd113463f0733aa6bfc7cab0b88dcb8b318 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 29 May 2020 23:23:29 +0000
Subject: [PATCH 267/290] updating DIRECTORY.md

---
 DIRECTORY.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 189d6041b..d90326050 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -32,7 +32,7 @@
   * [Linkedlist Implentation Usingarray](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/linkedList_implentation_usingArray.cpp)
   * [List Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/List%20Array.cpp)
   * [Morrisinorder](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/MorrisInorder.cpp)
-  * [Queue Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Queue%20Using%20Array.cpp)
+  * [Queue Using Array2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Queue%20Using%20Array2.cpp)
   * [Queue Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Queue%20Using%20Linked%20List.cpp)
   * Queue
     * [Queue](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue/queue.cpp)

From fed47f610ce64ecb4fa78219abd2262f47ec0484 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 19:24:24 -0400
Subject: [PATCH 268/290] git pull & then push

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 3fb7374e6..a8d61e423 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -54,4 +54,4 @@ jobs:
           line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
           line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
       - name: Git Push
-        run: git push
+        run: git pull && git push

From edb3d51ec259e80e4da596a4aaae27505def43bc Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 29 May 2020 23:26:28 +0000
Subject: [PATCH 269/290] formatting filenames
 d7af6fdc8cb08578de6980d412e6e1caca1a1bcf

---
 data_structure/{AVLtree.cpp => avltree.cpp}                       | 0
 data_structure/{Binary Search Tree.cpp => binary_search_tree.cpp} | 0
 data_structure/{Binaryheap.cpp => binaryheap.cpp}                 | 0
 ...using_Linked_List.cpp => circular_queue_using_linked_list.cpp} | 0
 ...tion_usingArray.cpp => linkedlist_implentation_usingarray.cpp} | 0
 data_structure/{List Array.cpp => list_array.cpp}                 | 0
 data_structure/{MorrisInorder.cpp => morrisinorder.cpp}           | 0
 data_structure/{Queue Using Array2.cpp => queue_using_array2.cpp} | 0
 .../{Queue Using Linked List.cpp => queue_using_linked_list.cpp}  | 0
 data_structure/{Stack Using Array.cpp => stack_using_array.cpp}   | 0
 .../{Stack Using Linked List.cpp => stack_using_linked_list.cpp}  | 0
 data_structure/{Tree.cpp => tree.cpp}                             | 0
 dynamic_programming/{0-1 Knapsack.cpp => 0_1_knapsack.cpp}        | 0
 dynamic_programming/{Bellman-Ford.cpp => bellman_ford.cpp}        | 0
 dynamic_programming/{Catalan-Numbers.cpp => catalan_numbers.cpp}  | 0
 dynamic_programming/{Coin-Change.cpp => coin_change.cpp}          | 0
 dynamic_programming/{Cut Rod.cpp => cut_rod.cpp}                  | 0
 dynamic_programming/{Edit Distance.cpp => edit_distance.cpp}      | 0
 .../{Egg-Dropping-Puzzle.cpp => egg_dropping_puzzle.cpp}          | 0
 .../{Fibonacci_Bottom_Up.cpp => fibonacci_bottom_up.cpp}          | 0
 .../{Fibonacci_Top_Down.cpp => fibonacci_top_down.cpp}            | 0
 dynamic_programming/{Floyd-Warshall.cpp => floyd_warshall.cpp}    | 0
 ...gest Common Subsequence.cpp => longest_common_subsequence.cpp} | 0
 ...reasing Subsequence.cpp => longest_increasing_subsequence.cpp} | 0
 ...nce (nlogn).cpp => longest_increasing_subsequence_(nlogn).cpp} | 0
 ...x-Chain-Multiplication.cpp => matrix_chain_multiplication.cpp} | 0
 graph/{BFS.cpp => bfs.cpp}                                        | 0
 graph/{DFS.cpp => dfs.cpp}                                        | 0
 graph/{Dijkstra.cpp => dijkstra.cpp}                              | 0
 graph/{Kruskal.cpp => kruskal.cpp}                                | 0
 graph/{Topological-Sort.cpp => topological_sort.cpp}              | 0
 greedy_algorithms/{Dijkstra.cpp => dijkstra.cpp}                  | 0
 greedy_algorithms/{Knapsack.cpp => knapsack.cpp}                  | 0
 ...nimum Spanning Tree.cpp => kruskals_minimum_spanning_tree.cpp} | 0
 ... Minimum Spanning Tree.cpp => prims_minimum_spanning_tree.cpp} | 0
 hashing/{Chaining.cpp => chaining.cpp}                            | 0
 .../{Array Left Rotation.cpp => array_left_rotation.cpp}          | 0
 .../{Array Right Rotation.cpp => array_right_rotation.cpp}        | 0
 .../{Circular Linked List.cpp => circular_linked_list.cpp}        | 0
 ...cular Queue Using Array.cpp => circular_queue_using_array.cpp} | 0
 ...{Intersection_of_2_arrays.cpp => intersection_of_2_arrays.cpp} | 0
 ...sing Recusion.cpp => reverse_a_linked_list_using_recusion.cpp} | 0
 .../{selectionSortLinkedList.cpp => selectionsortlinkedlist.cpp}  | 0
 .../{Union_of_2_arrays.cpp => union_of_2_arrays.cpp}              | 0
 range_queries/{FenwickTree.cpp => fenwicktree.cpp}                | 0
 range_queries/{MO.cpp => mo.cpp}                                  | 0
 range_queries/{segTree.cpp => segtree.cpp}                        | 0
 sorting/{Counting_Sort.cpp => counting_sort.cpp}                  | 0
 48 files changed, 0 insertions(+), 0 deletions(-)
 rename data_structure/{AVLtree.cpp => avltree.cpp} (100%)
 rename data_structure/{Binary Search Tree.cpp => binary_search_tree.cpp} (100%)
 rename data_structure/{Binaryheap.cpp => binaryheap.cpp} (100%)
 rename data_structure/{circular_Queue_using_Linked_List.cpp => circular_queue_using_linked_list.cpp} (100%)
 rename data_structure/{linkedList_implentation_usingArray.cpp => linkedlist_implentation_usingarray.cpp} (100%)
 rename data_structure/{List Array.cpp => list_array.cpp} (100%)
 rename data_structure/{MorrisInorder.cpp => morrisinorder.cpp} (100%)
 rename data_structure/{Queue Using Array2.cpp => queue_using_array2.cpp} (100%)
 rename data_structure/{Queue Using Linked List.cpp => queue_using_linked_list.cpp} (100%)
 rename data_structure/{Stack Using Array.cpp => stack_using_array.cpp} (100%)
 rename data_structure/{Stack Using Linked List.cpp => stack_using_linked_list.cpp} (100%)
 rename data_structure/{Tree.cpp => tree.cpp} (100%)
 rename dynamic_programming/{0-1 Knapsack.cpp => 0_1_knapsack.cpp} (100%)
 rename dynamic_programming/{Bellman-Ford.cpp => bellman_ford.cpp} (100%)
 rename dynamic_programming/{Catalan-Numbers.cpp => catalan_numbers.cpp} (100%)
 rename dynamic_programming/{Coin-Change.cpp => coin_change.cpp} (100%)
 rename dynamic_programming/{Cut Rod.cpp => cut_rod.cpp} (100%)
 rename dynamic_programming/{Edit Distance.cpp => edit_distance.cpp} (100%)
 rename dynamic_programming/{Egg-Dropping-Puzzle.cpp => egg_dropping_puzzle.cpp} (100%)
 rename dynamic_programming/{Fibonacci_Bottom_Up.cpp => fibonacci_bottom_up.cpp} (100%)
 rename dynamic_programming/{Fibonacci_Top_Down.cpp => fibonacci_top_down.cpp} (100%)
 rename dynamic_programming/{Floyd-Warshall.cpp => floyd_warshall.cpp} (100%)
 rename dynamic_programming/{Longest Common Subsequence.cpp => longest_common_subsequence.cpp} (100%)
 rename dynamic_programming/{Longest Increasing Subsequence.cpp => longest_increasing_subsequence.cpp} (100%)
 rename dynamic_programming/{Longest Increasing Subsequence (nlogn).cpp => longest_increasing_subsequence_(nlogn).cpp} (100%)
 rename dynamic_programming/{Matrix-Chain-Multiplication.cpp => matrix_chain_multiplication.cpp} (100%)
 rename graph/{BFS.cpp => bfs.cpp} (100%)
 rename graph/{DFS.cpp => dfs.cpp} (100%)
 rename graph/{Dijkstra.cpp => dijkstra.cpp} (100%)
 rename graph/{Kruskal.cpp => kruskal.cpp} (100%)
 rename graph/{Topological-Sort.cpp => topological_sort.cpp} (100%)
 rename greedy_algorithms/{Dijkstra.cpp => dijkstra.cpp} (100%)
 rename greedy_algorithms/{Knapsack.cpp => knapsack.cpp} (100%)
 rename greedy_algorithms/{Kruskals Minimum Spanning Tree.cpp => kruskals_minimum_spanning_tree.cpp} (100%)
 rename greedy_algorithms/{Prims Minimum Spanning Tree.cpp => prims_minimum_spanning_tree.cpp} (100%)
 rename hashing/{Chaining.cpp => chaining.cpp} (100%)
 rename operations_on_datastructures/{Array Left Rotation.cpp => array_left_rotation.cpp} (100%)
 rename operations_on_datastructures/{Array Right Rotation.cpp => array_right_rotation.cpp} (100%)
 rename operations_on_datastructures/{Circular Linked List.cpp => circular_linked_list.cpp} (100%)
 rename operations_on_datastructures/{Circular Queue Using Array.cpp => circular_queue_using_array.cpp} (100%)
 rename operations_on_datastructures/{Intersection_of_2_arrays.cpp => intersection_of_2_arrays.cpp} (100%)
 rename operations_on_datastructures/{Reverse a Linked List using Recusion.cpp => reverse_a_linked_list_using_recusion.cpp} (100%)
 rename operations_on_datastructures/{selectionSortLinkedList.cpp => selectionsortlinkedlist.cpp} (100%)
 rename operations_on_datastructures/{Union_of_2_arrays.cpp => union_of_2_arrays.cpp} (100%)
 rename range_queries/{FenwickTree.cpp => fenwicktree.cpp} (100%)
 rename range_queries/{MO.cpp => mo.cpp} (100%)
 rename range_queries/{segTree.cpp => segtree.cpp} (100%)
 rename sorting/{Counting_Sort.cpp => counting_sort.cpp} (100%)

diff --git a/data_structure/AVLtree.cpp b/data_structure/avltree.cpp
similarity index 100%
rename from data_structure/AVLtree.cpp
rename to data_structure/avltree.cpp
diff --git a/data_structure/Binary Search Tree.cpp b/data_structure/binary_search_tree.cpp
similarity index 100%
rename from data_structure/Binary Search Tree.cpp
rename to data_structure/binary_search_tree.cpp
diff --git a/data_structure/Binaryheap.cpp b/data_structure/binaryheap.cpp
similarity index 100%
rename from data_structure/Binaryheap.cpp
rename to data_structure/binaryheap.cpp
diff --git a/data_structure/circular_Queue_using_Linked_List.cpp b/data_structure/circular_queue_using_linked_list.cpp
similarity index 100%
rename from data_structure/circular_Queue_using_Linked_List.cpp
rename to data_structure/circular_queue_using_linked_list.cpp
diff --git a/data_structure/linkedList_implentation_usingArray.cpp b/data_structure/linkedlist_implentation_usingarray.cpp
similarity index 100%
rename from data_structure/linkedList_implentation_usingArray.cpp
rename to data_structure/linkedlist_implentation_usingarray.cpp
diff --git a/data_structure/List Array.cpp b/data_structure/list_array.cpp
similarity index 100%
rename from data_structure/List Array.cpp
rename to data_structure/list_array.cpp
diff --git a/data_structure/MorrisInorder.cpp b/data_structure/morrisinorder.cpp
similarity index 100%
rename from data_structure/MorrisInorder.cpp
rename to data_structure/morrisinorder.cpp
diff --git a/data_structure/Queue Using Array2.cpp b/data_structure/queue_using_array2.cpp
similarity index 100%
rename from data_structure/Queue Using Array2.cpp
rename to data_structure/queue_using_array2.cpp
diff --git a/data_structure/Queue Using Linked List.cpp b/data_structure/queue_using_linked_list.cpp
similarity index 100%
rename from data_structure/Queue Using Linked List.cpp
rename to data_structure/queue_using_linked_list.cpp
diff --git a/data_structure/Stack Using Array.cpp b/data_structure/stack_using_array.cpp
similarity index 100%
rename from data_structure/Stack Using Array.cpp
rename to data_structure/stack_using_array.cpp
diff --git a/data_structure/Stack Using Linked List.cpp b/data_structure/stack_using_linked_list.cpp
similarity index 100%
rename from data_structure/Stack Using Linked List.cpp
rename to data_structure/stack_using_linked_list.cpp
diff --git a/data_structure/Tree.cpp b/data_structure/tree.cpp
similarity index 100%
rename from data_structure/Tree.cpp
rename to data_structure/tree.cpp
diff --git a/dynamic_programming/0-1 Knapsack.cpp b/dynamic_programming/0_1_knapsack.cpp
similarity index 100%
rename from dynamic_programming/0-1 Knapsack.cpp
rename to dynamic_programming/0_1_knapsack.cpp
diff --git a/dynamic_programming/Bellman-Ford.cpp b/dynamic_programming/bellman_ford.cpp
similarity index 100%
rename from dynamic_programming/Bellman-Ford.cpp
rename to dynamic_programming/bellman_ford.cpp
diff --git a/dynamic_programming/Catalan-Numbers.cpp b/dynamic_programming/catalan_numbers.cpp
similarity index 100%
rename from dynamic_programming/Catalan-Numbers.cpp
rename to dynamic_programming/catalan_numbers.cpp
diff --git a/dynamic_programming/Coin-Change.cpp b/dynamic_programming/coin_change.cpp
similarity index 100%
rename from dynamic_programming/Coin-Change.cpp
rename to dynamic_programming/coin_change.cpp
diff --git a/dynamic_programming/Cut Rod.cpp b/dynamic_programming/cut_rod.cpp
similarity index 100%
rename from dynamic_programming/Cut Rod.cpp
rename to dynamic_programming/cut_rod.cpp
diff --git a/dynamic_programming/Edit Distance.cpp b/dynamic_programming/edit_distance.cpp
similarity index 100%
rename from dynamic_programming/Edit Distance.cpp
rename to dynamic_programming/edit_distance.cpp
diff --git a/dynamic_programming/Egg-Dropping-Puzzle.cpp b/dynamic_programming/egg_dropping_puzzle.cpp
similarity index 100%
rename from dynamic_programming/Egg-Dropping-Puzzle.cpp
rename to dynamic_programming/egg_dropping_puzzle.cpp
diff --git a/dynamic_programming/Fibonacci_Bottom_Up.cpp b/dynamic_programming/fibonacci_bottom_up.cpp
similarity index 100%
rename from dynamic_programming/Fibonacci_Bottom_Up.cpp
rename to dynamic_programming/fibonacci_bottom_up.cpp
diff --git a/dynamic_programming/Fibonacci_Top_Down.cpp b/dynamic_programming/fibonacci_top_down.cpp
similarity index 100%
rename from dynamic_programming/Fibonacci_Top_Down.cpp
rename to dynamic_programming/fibonacci_top_down.cpp
diff --git a/dynamic_programming/Floyd-Warshall.cpp b/dynamic_programming/floyd_warshall.cpp
similarity index 100%
rename from dynamic_programming/Floyd-Warshall.cpp
rename to dynamic_programming/floyd_warshall.cpp
diff --git a/dynamic_programming/Longest Common Subsequence.cpp b/dynamic_programming/longest_common_subsequence.cpp
similarity index 100%
rename from dynamic_programming/Longest Common Subsequence.cpp
rename to dynamic_programming/longest_common_subsequence.cpp
diff --git a/dynamic_programming/Longest Increasing Subsequence.cpp b/dynamic_programming/longest_increasing_subsequence.cpp
similarity index 100%
rename from dynamic_programming/Longest Increasing Subsequence.cpp
rename to dynamic_programming/longest_increasing_subsequence.cpp
diff --git a/dynamic_programming/Longest Increasing Subsequence (nlogn).cpp b/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
similarity index 100%
rename from dynamic_programming/Longest Increasing Subsequence (nlogn).cpp
rename to dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
diff --git a/dynamic_programming/Matrix-Chain-Multiplication.cpp b/dynamic_programming/matrix_chain_multiplication.cpp
similarity index 100%
rename from dynamic_programming/Matrix-Chain-Multiplication.cpp
rename to dynamic_programming/matrix_chain_multiplication.cpp
diff --git a/graph/BFS.cpp b/graph/bfs.cpp
similarity index 100%
rename from graph/BFS.cpp
rename to graph/bfs.cpp
diff --git a/graph/DFS.cpp b/graph/dfs.cpp
similarity index 100%
rename from graph/DFS.cpp
rename to graph/dfs.cpp
diff --git a/graph/Dijkstra.cpp b/graph/dijkstra.cpp
similarity index 100%
rename from graph/Dijkstra.cpp
rename to graph/dijkstra.cpp
diff --git a/graph/Kruskal.cpp b/graph/kruskal.cpp
similarity index 100%
rename from graph/Kruskal.cpp
rename to graph/kruskal.cpp
diff --git a/graph/Topological-Sort.cpp b/graph/topological_sort.cpp
similarity index 100%
rename from graph/Topological-Sort.cpp
rename to graph/topological_sort.cpp
diff --git a/greedy_algorithms/Dijkstra.cpp b/greedy_algorithms/dijkstra.cpp
similarity index 100%
rename from greedy_algorithms/Dijkstra.cpp
rename to greedy_algorithms/dijkstra.cpp
diff --git a/greedy_algorithms/Knapsack.cpp b/greedy_algorithms/knapsack.cpp
similarity index 100%
rename from greedy_algorithms/Knapsack.cpp
rename to greedy_algorithms/knapsack.cpp
diff --git a/greedy_algorithms/Kruskals Minimum Spanning Tree.cpp b/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
similarity index 100%
rename from greedy_algorithms/Kruskals Minimum Spanning Tree.cpp
rename to greedy_algorithms/kruskals_minimum_spanning_tree.cpp
diff --git a/greedy_algorithms/Prims Minimum Spanning Tree.cpp b/greedy_algorithms/prims_minimum_spanning_tree.cpp
similarity index 100%
rename from greedy_algorithms/Prims Minimum Spanning Tree.cpp
rename to greedy_algorithms/prims_minimum_spanning_tree.cpp
diff --git a/hashing/Chaining.cpp b/hashing/chaining.cpp
similarity index 100%
rename from hashing/Chaining.cpp
rename to hashing/chaining.cpp
diff --git a/operations_on_datastructures/Array Left Rotation.cpp b/operations_on_datastructures/array_left_rotation.cpp
similarity index 100%
rename from operations_on_datastructures/Array Left Rotation.cpp
rename to operations_on_datastructures/array_left_rotation.cpp
diff --git a/operations_on_datastructures/Array Right Rotation.cpp b/operations_on_datastructures/array_right_rotation.cpp
similarity index 100%
rename from operations_on_datastructures/Array Right Rotation.cpp
rename to operations_on_datastructures/array_right_rotation.cpp
diff --git a/operations_on_datastructures/Circular Linked List.cpp b/operations_on_datastructures/circular_linked_list.cpp
similarity index 100%
rename from operations_on_datastructures/Circular Linked List.cpp
rename to operations_on_datastructures/circular_linked_list.cpp
diff --git a/operations_on_datastructures/Circular Queue Using Array.cpp b/operations_on_datastructures/circular_queue_using_array.cpp
similarity index 100%
rename from operations_on_datastructures/Circular Queue Using Array.cpp
rename to operations_on_datastructures/circular_queue_using_array.cpp
diff --git a/operations_on_datastructures/Intersection_of_2_arrays.cpp b/operations_on_datastructures/intersection_of_2_arrays.cpp
similarity index 100%
rename from operations_on_datastructures/Intersection_of_2_arrays.cpp
rename to operations_on_datastructures/intersection_of_2_arrays.cpp
diff --git a/operations_on_datastructures/Reverse a Linked List using Recusion.cpp b/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
similarity index 100%
rename from operations_on_datastructures/Reverse a Linked List using Recusion.cpp
rename to operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
diff --git a/operations_on_datastructures/selectionSortLinkedList.cpp b/operations_on_datastructures/selectionsortlinkedlist.cpp
similarity index 100%
rename from operations_on_datastructures/selectionSortLinkedList.cpp
rename to operations_on_datastructures/selectionsortlinkedlist.cpp
diff --git a/operations_on_datastructures/Union_of_2_arrays.cpp b/operations_on_datastructures/union_of_2_arrays.cpp
similarity index 100%
rename from operations_on_datastructures/Union_of_2_arrays.cpp
rename to operations_on_datastructures/union_of_2_arrays.cpp
diff --git a/range_queries/FenwickTree.cpp b/range_queries/fenwicktree.cpp
similarity index 100%
rename from range_queries/FenwickTree.cpp
rename to range_queries/fenwicktree.cpp
diff --git a/range_queries/MO.cpp b/range_queries/mo.cpp
similarity index 100%
rename from range_queries/MO.cpp
rename to range_queries/mo.cpp
diff --git a/range_queries/segTree.cpp b/range_queries/segtree.cpp
similarity index 100%
rename from range_queries/segTree.cpp
rename to range_queries/segtree.cpp
diff --git a/sorting/Counting_Sort.cpp b/sorting/counting_sort.cpp
similarity index 100%
rename from sorting/Counting_Sort.cpp
rename to sorting/counting_sort.cpp

From 7ad1f171c139e206761c17d50dd7093a6875ee5a Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 29 May 2020 23:26:30 +0000
Subject: [PATCH 270/290] formatting source-code for
 d7af6fdc8cb08578de6980d412e6e1caca1a1bcf

---
 backtracking/graph_coloring.cpp               |   8 +-
 backtracking/knight_tour.cpp                  |  69 ++--
 backtracking/minimax.cpp                      |   8 +-
 backtracking/n_queens.cpp                     |  12 +-
 .../n_queens_all_solution_optimised.cpp       |  68 ++--
 backtracking/nqueen_print_all_solutions.cpp   |  36 +-
 backtracking/rat_maze.cpp                     | 108 +++---
 backtracking/sudoku_solve.cpp                 |  41 +--
 .../bisection_method.cpp                      |  29 +-
 .../false_position.cpp                        |  25 +-
 .../gaussian_elimination.cpp                  |  33 +-
 .../newton_raphson_method.cpp                 |  12 +-
 .../ordinary_least_squares_regressor.cpp      | 112 ++++--
 .../successive_approximation.cpp              |   9 +-
 data_structure/avltree.cpp                    | 215 ++++++-----
 data_structure/binary_search_tree.cpp         | 336 +++++++++---------
 data_structure/binaryheap.cpp                 |  10 +-
 .../circular_queue_using_linked_list.cpp      |   2 +-
 data_structure/cll/cll.cpp                    |  70 ++--
 data_structure/cll/cll.h                      |  50 +--
 data_structure/cll/main_cll.cpp               |  72 ++--
 data_structure/disjoint_set.cpp               | 114 +++---
 data_structure/doubly_linked_list.cpp         | 278 ++++++++-------
 data_structure/linked_list.cpp                | 257 ++++++++------
 .../linkedlist_implentation_usingarray.cpp    |  26 +-
 data_structure/list_array.cpp                 | 324 +++++++++--------
 data_structure/morrisinorder.cpp              | 170 ++++-----
 data_structure/queue/queue.cpp                |  28 +-
 data_structure/queue/queue.h                  |  27 +-
 data_structure/queue/test_queue.cpp           |  28 +-
 data_structure/queue_using_array.cpp          |  72 ++--
 data_structure/queue_using_array2.cpp         | 101 +++---
 data_structure/queue_using_linked_list.cpp    |   4 +-
 data_structure/queue_using_linkedlist.cpp     | 129 +++----
 data_structure/stack_using_array.cpp          | 110 +++---
 data_structure/stack_using_linked_list.cpp    |  95 +++--
 data_structure/stk/main.cpp                   |  28 +-
 data_structure/stk/stack.cpp                  |  27 +-
 data_structure/stk/stack.h                    |  29 +-
 data_structure/stk/test_stack.cpp             |  34 +-
 data_structure/tree.cpp                       |  20 +-
 data_structure/trie_tree.cpp                  |  91 +++--
 dynamic_programming/0_1_knapsack.cpp          |  75 ++--
 dynamic_programming/armstrong_number.cpp      |  32 +-
 dynamic_programming/bellman_ford.cpp          | 191 +++++-----
 dynamic_programming/catalan_numbers.cpp       |   4 +-
 dynamic_programming/coin_change.cpp           |  62 ++--
 dynamic_programming/cut_rod.cpp               |   9 +-
 dynamic_programming/edit_distance.cpp         |  34 +-
 dynamic_programming/egg_dropping_puzzle.cpp   |  10 +-
 dynamic_programming/fibonacci_bottom_up.cpp   |  32 +-
 dynamic_programming/fibonacci_top_down.cpp    |  34 +-
 dynamic_programming/floyd_warshall.cpp        | 162 +++++----
 dynamic_programming/kadane.cpp                |  17 +-
 dynamic_programming/longest_common_string.cpp |  76 ++--
 .../longest_common_subsequence.cpp            |  11 +-
 .../longest_increasing_subsequence.cpp        |  62 ++--
 ...longest_increasing_subsequence_(nlogn).cpp |  22 +-
 .../matrix_chain_multiplication.cpp           |  73 ++--
 .../searching_of_element_in_dynamic_array.cpp |  80 +++--
 dynamic_programming/tree_height.cpp           |  41 ++-
 graph/bfs.cpp                                 | 104 +++---
 .../bridge_finding_with_tarjan_algorithm.cpp  |  54 +--
 graph/connected_components.cpp                |  71 ++--
 graph/connected_components_with_dsu.cpp       |  29 +-
 graph/dfs.cpp                                 |  34 +-
 graph/dijkstra.cpp                            |  17 +-
 graph/kosaraju.cpp                            | 147 ++++----
 graph/kruskal.cpp                             | 178 +++++-----
 graph/lca.cpp                                 |  44 +--
 ...th_ford_fulkerson_and_edmond_karp_algo.cpp |  94 ++---
 graph/prim.cpp                                |  33 +-
 graph/topological_sort.cpp                    |  71 ++--
 graph/topological_sort_by_kahns_algo.cpp      |  50 ++-
 greedy_algorithms/dijkstra.cpp                |  34 +-
 greedy_algorithms/huffman.cpp                 | 213 ++++++-----
 greedy_algorithms/knapsack.cpp                | 130 ++++---
 .../kruskals_minimum_spanning_tree.cpp        |  45 ++-
 .../prims_minimum_spanning_tree.cpp           |  94 +++--
 hashing/chaining.cpp                          | 220 ++++++------
 hashing/double_hash_hash_table.cpp            | 144 +++++---
 hashing/linear_probing_hash_table.cpp         | 130 ++++---
 hashing/quadratic_probing_hash_table.cpp      | 150 +++++---
 math/binary_exponent.cpp                      |  36 +-
 math/double_factorial.cpp                     |  18 +-
 math/eulers_totient_function.cpp              |  25 +-
 math/extended_euclid_algorithm.cpp            |  28 +-
 math/factorial.cpp                            |   6 +-
 math/fast_power.cpp                           |  27 +-
 math/fibonacci.cpp                            |   6 +-
 math/fibonacci_fast.cpp                       |   9 +-
 math/fibonacci_large.cpp                      |  16 +-
 math/gcd_iterative_euclidean.cpp              |  29 +-
 math/gcd_of_n_numbers.cpp                     |   9 +-
 math/gcd_recursive_euclidean.cpp              |  19 +-
 math/large_factorial.cpp                      |  34 +-
 math/large_number.h                           |  94 +++--
 .../modular_inverse_fermat_little_theorem.cpp |  35 +-
 math/number_of_positive_divisors.cpp          |  31 +-
 math/power_for_huge_numbers.cpp               |  21 +-
 math/prime_factorization.cpp                  |  36 +-
 math/prime_numbers.cpp                        |  12 +-
 math/primes_up_to_billion.cpp                 |  12 +-
 math/sieve_of_eratosthenes.cpp                |  30 +-
 math/sqrt_double.cpp                          |  22 +-
 math/string_fibonacci.cpp                     |  34 +-
 .../array_left_rotation.cpp                   |  68 ++--
 .../array_right_rotation.cpp                  |   3 +-
 .../circular_linked_list.cpp                  | 168 ++++-----
 .../circular_queue_using_array.cpp            |  97 +++--
 .../get_size_of_linked_list.cpp               |  15 +-
 .../intersection_of_2_arrays.cpp              |  48 ++-
 .../reverse_a_linked_list_using_recusion.cpp  |  98 ++---
 .../selectionsortlinkedlist.cpp               |  95 +++--
 .../union_of_2_arrays.cpp                     |  52 ++-
 others/buzz_number.cpp                        |   6 +-
 others/decimal_to_binary.cpp                  |  15 +-
 others/decimal_to_hexadecimal.cpp             |   6 +-
 others/decimal_to_roman_numeral.cpp           |  78 ++--
 others/fast_interger_input.cpp                |  12 +-
 others/happy_number.cpp                       |  14 +-
 others/matrix_exponentiation.cpp              |  49 ++-
 others/palindrome_of_number.cpp               |   3 +-
 others/paranthesis_matching.cpp               |  46 ++-
 others/pascal_triangle.cpp                    |  27 +-
 others/primality_test.cpp                     |   9 +-
 others/smallest_circle.cpp                    |  51 ++-
 others/sparse_matrix.cpp                      |  15 +-
 others/spiral_print.cpp                       |  36 +-
 others/stairs_pattern.cpp                     |  15 +-
 others/tower_of_hanoi.cpp                     |  34 +-
 others/vector_important_functions.cpp         |   3 +-
 probability/addition_rule.cpp                 |   9 +-
 probability/bayes_theorem.cpp                 |   9 +-
 probability/binomial_dist.cpp                 |  24 +-
 probability/poisson_dist.cpp                  |  24 +-
 range_queries/bit.cpp                         |  37 +-
 range_queries/fenwicktree.cpp                 |  38 +-
 range_queries/mo.cpp                          | 104 +++---
 range_queries/segtree.cpp                     | 156 ++++----
 search/binary_search.cpp                      |  12 +-
 search/exponential_search.cpp                 |  18 +-
 search/hash_search.cpp                        |  34 +-
 search/interpolation_search.cpp               |   9 +-
 search/interpolation_search2.cpp              |   9 +-
 search/jump_search.cpp                        |  12 +-
 search/linear_search.cpp                      |  22 +-
 search/median_search.cpp                      |  36 +-
 search/ternary_search.cpp                     |  35 +-
 search/text_search.cpp                        |  20 +-
 sorting/bead_sort.cpp                         |  21 +-
 sorting/bitonic_sort.cpp                      |  21 +-
 sorting/bubble_sort.cpp                       |  25 +-
 sorting/bucket_sort.cpp                       |   9 +-
 sorting/cocktail_selection_sort.cpp           |  64 ++--
 sorting/comb_sort.cpp                         |  18 +-
 sorting/counting_sort.cpp                     |  71 ++--
 sorting/counting_sort_string.cpp              |  13 +-
 sorting/heap_sort.cpp                         |  27 +-
 sorting/insertion_sort.cpp                    |  15 +-
 sorting/library_sort.cpp                      |  40 ++-
 sorting/merge_sort.cpp                        |  34 +-
 sorting/non_recursive_merge_sort.cpp          |  24 +-
 sorting/numeric_string_sort.cpp               |  24 +-
 sorting/odd_even_sort.cpp                     |  75 ++--
 sorting/quick_sort.cpp                        |  24 +-
 sorting/radix_sort.cpp                        |  39 +-
 sorting/selection_sort.cpp                    |  58 +--
 sorting/shell_sort.cpp                        |  25 +-
 sorting/shell_sort2.cpp                       | 141 ++++----
 sorting/slow_sort.cpp                         |  18 +-
 sorting/swap_sort.cpp                         |  21 +-
 sorting/tim_sort.cpp                          |  43 ++-
 strings/brute_force_string_searching.cpp      |  18 +-
 strings/knuth_morris_pratt.cpp                |  35 +-
 strings/rabin_karp.cpp                        |  37 +-
 176 files changed, 5342 insertions(+), 4288 deletions(-)

diff --git a/backtracking/graph_coloring.cpp b/backtracking/graph_coloring.cpp
index cadc6d5ec..5d0049902 100644
--- a/backtracking/graph_coloring.cpp
+++ b/backtracking/graph_coloring.cpp
@@ -48,8 +48,7 @@ void graphColoring(bool graph[V][V], int m, int color[], int v)
 void printSolution(int color[])
 {
     printf(" Following are the assigned colors \n");
-    for (int i = 0; i < V; i++)
-        printf(" %d ", color[i]);
+    for (int i = 0; i < V; i++) printf(" %d ", color[i]);
     printf("\n");
 }
 
@@ -69,12 +68,11 @@ int main()
         {1, 1, 0, 1},
         {1, 0, 1, 0},
     };
-    int m = 3; // Number of colors
+    int m = 3;  // Number of colors
 
     int color[V];
 
-    for (int i = 0; i < V; i++)
-        color[i] = 0;
+    for (int i = 0; i < V; i++) color[i] = 0;
 
     graphColoring(graph, m, color, 0);
     return 0;
diff --git a/backtracking/knight_tour.cpp b/backtracking/knight_tour.cpp
index fbb8a6f96..72b900376 100644
--- a/backtracking/knight_tour.cpp
+++ b/backtracking/knight_tour.cpp
@@ -1,68 +1,65 @@
 #include <iostream>
-# define n 8
+#define n 8
 
 /**
 A knight's tour is a sequence of moves of a knight on a chessboard
-such that the knight visits every square only once. If the knight 
-ends on a square that is one knight's move from the beginning 
-square (so that it could tour the board again immediately, following 
+such that the knight visits every square only once. If the knight
+ends on a square that is one knight's move from the beginning
+square (so that it could tour the board again immediately, following
 the same path), the tour is closed; otherwise, it is open.
 **/
 
 using namespace std;
-bool issafe(int x,int y,int sol[n][n])
+bool issafe(int x, int y, int sol[n][n])
 {
-    return (x<n && x>=0 && y<n && y>=0 && sol[x][y]==-1);
-
+    return (x < n && x >= 0 && y < n && y >= 0 && sol[x][y] == -1);
 }
-bool solve(int x,int y, int mov, int sol[n][n], int xmov[n], int ymov[n])
+bool solve(int x, int y, int mov, int sol[n][n], int xmov[n], int ymov[n])
 {
-    int k,xnext,ynext;
+    int k, xnext, ynext;
 
-    if(mov == n*n)
+    if (mov == n * n)
         return true;
 
-    for(k=0;k<8;k++)
+    for (k = 0; k < 8; k++)
     {
-        xnext=x+xmov[k];
-        ynext=y+ymov[k];
+        xnext = x + xmov[k];
+        ynext = y + ymov[k];
 
-        if(issafe(xnext,ynext,sol))
-            {
-                sol[xnext][ynext]=mov;
+        if (issafe(xnext, ynext, sol))
+        {
+            sol[xnext][ynext] = mov;
 
-                if(solve(xnext,ynext,mov+1,sol,xmov,ymov)==true)
-                    return true;
-                else
-                    sol[xnext][ynext]=-1;
-            }
+            if (solve(xnext, ynext, mov + 1, sol, xmov, ymov) == true)
+                return true;
+            else
+                sol[xnext][ynext] = -1;
+        }
     }
     return false;
 }
 int main()
 {
-    //initialize();
+    // initialize();
 
     int sol[n][n];
-    int i,j;
-    for(i=0;i<n;i++)
-        for(j=0;j<n;j++)
-            sol[i][j]=-1;
+    int i, j;
+    for (i = 0; i < n; i++)
+        for (j = 0; j < n; j++) sol[i][j] = -1;
 
-    int xmov[8] = {  2, 1, -1, -2, -2, -1,  1,  2 };
-    int ymov[8] = {  1, 2,  2,  1, -1, -2, -2, -1 };
-    sol[0][0]=0;
+    int xmov[8] = {2, 1, -1, -2, -2, -1, 1, 2};
+    int ymov[8] = {1, 2, 2, 1, -1, -2, -2, -1};
+    sol[0][0] = 0;
 
-    bool flag=solve(0,0,1,sol,xmov,ymov);
-    if(flag==false)
-        cout<<"solution doesnot exist \n";
+    bool flag = solve(0, 0, 1, sol, xmov, ymov);
+    if (flag == false)
+        cout << "solution doesnot exist \n";
     else
     {
-        for(i=0;i<n;i++)
+        for (i = 0; i < n; i++)
         {
-            for(j=0;j<n;j++)
-                cout<<sol[i][j]<<"  ";
-            cout<<"\n";
+            for (j = 0; j < n; j++) cout << sol[i][j] << "  ";
+            cout << "\n";
         }
     }
 }
diff --git a/backtracking/minimax.cpp b/backtracking/minimax.cpp
index e4fd9eb82..110e9e7ed 100644
--- a/backtracking/minimax.cpp
+++ b/backtracking/minimax.cpp
@@ -9,7 +9,8 @@ using std::min;
 using std::vector;
 
 int minimax(int depth, int node_index, bool is_max, vector<int> scores,
-            int height) {
+            int height)
+{
     if (depth == height)
         return scores[node_index];
 
@@ -19,8 +20,9 @@ int minimax(int depth, int node_index, bool is_max, vector<int> scores,
     return is_max ? max(v1, v2) : min(v1, v2);
 }
 
-int main() {
-    vector<int> scores = { 90, 23, 6, 33, 21, 65, 123, 34423 };
+int main()
+{
+    vector<int> scores = {90, 23, 6, 33, 21, 65, 123, 34423};
     int height = log2(scores.size());
 
     cout << "Optimal value: " << minimax(0, 0, true, scores, height) << endl;
diff --git a/backtracking/n_queens.cpp b/backtracking/n_queens.cpp
index 472aaa2fe..45d6f436c 100644
--- a/backtracking/n_queens.cpp
+++ b/backtracking/n_queens.cpp
@@ -7,8 +7,7 @@ void printSolution(int board[N][N])
     cout << "\n";
     for (int i = 0; i < N; i++)
     {
-        for (int j = 0; j < N; j++)
-            cout << "" << board[i][j];
+        for (int j = 0; j < N; j++) cout << "" << board[i][j];
         cout << "\n";
     }
 }
@@ -37,7 +36,6 @@ bool isSafe(int board[N][N], int row, int col)
 
 void solveNQ(int board[N][N], int col)
 {
-
     if (col >= N)
     {
         printSolution(board);
@@ -59,18 +57,14 @@ void solveNQ(int board[N][N], int col)
             /* recur to place rest of the queens */
             solveNQ(board, col + 1);
 
-            board[i][col] = 0; // BACKTRACK
+            board[i][col] = 0;  // BACKTRACK
         }
     }
 }
 
 int main()
 {
-
-    int board[N][N] = {{0, 0, 0, 0},
-                       {0, 0, 0, 0},
-                       {0, 0, 0, 0},
-                       {0, 0, 0, 0}};
+    int board[N][N] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
 
     solveNQ(board, 0);
     return 0;
diff --git a/backtracking/n_queens_all_solution_optimised.cpp b/backtracking/n_queens_all_solution_optimised.cpp
index 1db730f63..f27b3468b 100644
--- a/backtracking/n_queens_all_solution_optimised.cpp
+++ b/backtracking/n_queens_all_solution_optimised.cpp
@@ -1,50 +1,60 @@
 #include <iostream>
 #define n 4
-#define inc_loop(var, start, stop) for (int var=start; var <= stop; var++)
-#define dec_loop(var, start, stop) for (int var=start; var >= stop; var--)
-void PrintSol(int Board[n][n]) {
-    inc_loop(i, 0, n-1) {
-        inc_loop(j, 0, n-1)
-            std::cout << Board[i][j] << " ";
+#define inc_loop(var, start, stop) for (int var = start; var <= stop; var++)
+#define dec_loop(var, start, stop) for (int var = start; var >= stop; var--)
+void PrintSol(int Board[n][n])
+{
+    inc_loop(i, 0, n - 1)
+    {
+        inc_loop(j, 0, n - 1) std::cout << Board[i][j] << " ";
         std::cout << std::endl;
     }
     std::cout << std::endl;
-    if (n%2 == 0 || (n%2 == 1 && Board[n/2+1][0] != 1)) {
-        inc_loop(i, 0, n-1) {
-            dec_loop(j, n-1, 0)
-                std::cout << Board[i][j] << " ";
+    if (n % 2 == 0 || (n % 2 == 1 && Board[n / 2 + 1][0] != 1))
+    {
+        inc_loop(i, 0, n - 1)
+        {
+            dec_loop(j, n - 1, 0) std::cout << Board[i][j] << " ";
             std::cout << std::endl;
         }
         std::cout << std::endl;
     }
 }
 
-bool CanIMove(int Board[n][n], int row, int col) {
+bool CanIMove(int Board[n][n], int row, int col)
+{
     /// check in the row
-    inc_loop(i, 0, col-1) {
+    inc_loop(i, 0, col - 1)
+    {
         if (Board[row][i] == 1)
             return false;
     }
     /// check the first diagonal
-    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
+    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     /// check the second diagonal
-    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--) {
+    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     return true;
 }
 
-void NQueenSol(int Board[n][n], int col) {
-    if (col >= n) {
+void NQueenSol(int Board[n][n], int col)
+{
+    if (col >= n)
+    {
         PrintSol(Board);
         return;
     }
-    inc_loop(i, 0, n-1) {
-        if (CanIMove(Board, i, col)) {
+    inc_loop(i, 0, n - 1)
+    {
+        if (CanIMove(Board, i, col))
+        {
             Board[i][col] = 1;
             NQueenSol(Board, col + 1);
             Board[i][col] = 0;
@@ -52,19 +62,27 @@ void NQueenSol(int Board[n][n], int col) {
     }
 }
 
-int main() {
+int main()
+{
     int Board[n][n] = {0};
-    if (n%2 == 0) {
-        inc_loop(i, 0, n/2-1) {
-            if (CanIMove(Board, i, 0)) {
+    if (n % 2 == 0)
+    {
+        inc_loop(i, 0, n / 2 - 1)
+        {
+            if (CanIMove(Board, i, 0))
+            {
                 Board[i][0] = 1;
                 NQueenSol(Board, 1);
                 Board[i][0] = 0;
             }
         }
-    } else {
-        inc_loop(i, 0, n/2) {
-            if (CanIMove(Board, i, 0)) {
+    }
+    else
+    {
+        inc_loop(i, 0, n / 2)
+        {
+            if (CanIMove(Board, i, 0))
+            {
                 Board[i][0] = 1;
                 NQueenSol(Board, 1);
                 Board[i][0] = 0;
diff --git a/backtracking/nqueen_print_all_solutions.cpp b/backtracking/nqueen_print_all_solutions.cpp
index e6736da1e..d3d50998d 100644
--- a/backtracking/nqueen_print_all_solutions.cpp
+++ b/backtracking/nqueen_print_all_solutions.cpp
@@ -1,9 +1,12 @@
 #include <iostream>
 #define n 4
 
-void PrintSol(int Board[n][n]) {
-    for (int i = 0; i < n; i++) {
-        for (int j = 0; j < n; j++) {
+void PrintSol(int Board[n][n])
+{
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
             std::cout << Board[i][j] << " ";
         }
         std::cout << std::endl;
@@ -11,32 +14,40 @@ void PrintSol(int Board[n][n]) {
     std::cout << std::endl;
 }
 
-bool CanIMove(int Board[n][n], int row, int col) {
+bool CanIMove(int Board[n][n], int row, int col)
+{
     /// check in the row
-    for (int i = 0; i < col; i++) {
+    for (int i = 0; i < col; i++)
+    {
         if (Board[row][i] == 1)
             return false;
     }
     /// check the first diagonal
-    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
+    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     /// check the second diagonal
-    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--) {
+    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--)
+    {
         if (Board[i][j] == 1)
             return false;
     }
     return true;
 }
 
-void NQueenSol(int Board[n][n], int col) {
-    if (col >= n) {
+void NQueenSol(int Board[n][n], int col)
+{
+    if (col >= n)
+    {
         PrintSol(Board);
         return;
     }
-    for (int i = 0; i < n; i++) {
-        if (CanIMove(Board, i, col)) {
+    for (int i = 0; i < n; i++)
+    {
+        if (CanIMove(Board, i, col))
+        {
             Board[i][col] = 1;
             NQueenSol(Board, col + 1);
             Board[i][col] = 0;
@@ -44,7 +55,8 @@ void NQueenSol(int Board[n][n], int col) {
     }
 }
 
-int main() {
+int main()
+{
     int Board[n][n] = {0};
     NQueenSol(Board, 0);
 }
diff --git a/backtracking/rat_maze.cpp b/backtracking/rat_maze.cpp
index 307b5c7b0..5454a6c82 100644
--- a/backtracking/rat_maze.cpp
+++ b/backtracking/rat_maze.cpp
@@ -1,73 +1,73 @@
 /*
-	A Maze is given as N*N binary matrix of blocks where source block is the upper
-	left most block i.e., maze[0][0] and destination block is lower rightmost 
-	block i.e., maze[N-1][N-1]. A rat starts from source and has to reach destination.
-	The rat can move only in two directions: forward and down. In the maze matrix, 
-	0 means the block is dead end and 1 means the block can be used in the path 
-	from source to destination.
+    A Maze is given as N*N binary matrix of blocks where source block is the
+   upper left most block i.e., maze[0][0] and destination block is lower
+   rightmost block i.e., maze[N-1][N-1]. A rat starts from source and has to
+   reach destination. The rat can move only in two directions: forward and down.
+   In the maze matrix, 0 means the block is dead end and 1 means the block can
+   be used in the path from source to destination.
 */
 #include <iostream>
 #define size 4
 
 using namespace std;
 
-int solveMaze(int currposrow, int currposcol, int maze[size][size], int soln[size][size])
+int solveMaze(int currposrow, int currposcol, int maze[size][size],
+              int soln[size][size])
 {
-	if ((currposrow == size - 1) && (currposcol == size - 1))
-	{
-		soln[currposrow][currposcol] = 1;
-		for (int i = 0; i < size; ++i)
-		{
-			for (int j = 0; j < size; ++j)
-			{
-				cout << soln[i][j];
-			}
-			cout << endl;
-		}
-		return 1;
-	}
-	else
-	{
-		soln[currposrow][currposcol] = 1;
+    if ((currposrow == size - 1) && (currposcol == size - 1))
+    {
+        soln[currposrow][currposcol] = 1;
+        for (int i = 0; i < size; ++i)
+        {
+            for (int j = 0; j < size; ++j)
+            {
+                cout << soln[i][j];
+            }
+            cout << endl;
+        }
+        return 1;
+    }
+    else
+    {
+        soln[currposrow][currposcol] = 1;
 
-		// if there exist a solution by moving one step ahead in a collumn
-		if ((currposcol < size - 1) && maze[currposrow][currposcol + 1] == 1 && solveMaze(currposrow, currposcol + 1, maze, soln))
-		{
-			return 1;
-		}
+        // if there exist a solution by moving one step ahead in a collumn
+        if ((currposcol < size - 1) && maze[currposrow][currposcol + 1] == 1 &&
+            solveMaze(currposrow, currposcol + 1, maze, soln))
+        {
+            return 1;
+        }
 
-		// if there exists a solution by moving one step ahead in a row
-		if ((currposrow < size - 1) && maze[currposrow + 1][currposcol] == 1 && solveMaze(currposrow + 1, currposcol, maze, soln))
-		{
-			return 1;
-		}
+        // if there exists a solution by moving one step ahead in a row
+        if ((currposrow < size - 1) && maze[currposrow + 1][currposcol] == 1 &&
+            solveMaze(currposrow + 1, currposcol, maze, soln))
+        {
+            return 1;
+        }
 
-		// the backtracking part
-		soln[currposrow][currposcol] = 0;
-		return 0;
-	}
+        // the backtracking part
+        soln[currposrow][currposcol] = 0;
+        return 0;
+    }
 }
 
 int main(int argc, char const *argv[])
 {
-	int maze[size][size] = {
-		{1, 0, 1, 0},
-		{1, 0, 1, 1},
-		{1, 0, 0, 1},
-		{1, 1, 1, 1}};
+    int maze[size][size] = {
+        {1, 0, 1, 0}, {1, 0, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1}};
 
-	int soln[size][size];
+    int soln[size][size];
 
-	for (int i = 0; i < size; ++i)
-	{
-		for (int j = 0; j < size; ++j)
-		{
-			soln[i][j] = 0;
-		}
-	}
+    for (int i = 0; i < size; ++i)
+    {
+        for (int j = 0; j < size; ++j)
+        {
+            soln[i][j] = 0;
+        }
+    }
 
-	int currposrow = 0;
-	int currposcol = 0;
-	solveMaze(currposrow, currposcol, maze, soln);
-	return 0;
+    int currposrow = 0;
+    int currposcol = 0;
+    solveMaze(currposrow, currposcol, maze, soln);
+    return 0;
 }
diff --git a/backtracking/sudoku_solve.cpp b/backtracking/sudoku_solve.cpp
index 6a01fd395..c98040841 100644
--- a/backtracking/sudoku_solve.cpp
+++ b/backtracking/sudoku_solve.cpp
@@ -1,11 +1,11 @@
 #include <iostream>
 using namespace std;
-///N=9;
+/// N=9;
 int n = 9;
 
 bool isPossible(int mat[][9], int i, int j, int no)
 {
-    ///Row or col nahin hona chahiye
+    /// Row or col nahin hona chahiye
     for (int x = 0; x < n; x++)
     {
         if (mat[x][j] == no || mat[i][x] == no)
@@ -33,7 +33,6 @@ bool isPossible(int mat[][9], int i, int j, int no)
 }
 void printMat(int mat[][9])
 {
-
     for (int i = 0; i < n; i++)
     {
         for (int j = 0; j < n; j++)
@@ -54,60 +53,54 @@ void printMat(int mat[][9])
 
 bool solveSudoku(int mat[][9], int i, int j)
 {
-    ///Base Case
+    /// Base Case
     if (i == 9)
     {
-        ///Solve kr chuke hain for 9 rows already
+        /// Solve kr chuke hain for 9 rows already
         printMat(mat);
         return true;
     }
 
-    ///Crossed the last  Cell in the row
+    /// Crossed the last  Cell in the row
     if (j == 9)
     {
         return solveSudoku(mat, i + 1, 0);
     }
 
-    ///Blue Cell - Skip
+    /// Blue Cell - Skip
     if (mat[i][j] != 0)
     {
         return solveSudoku(mat, i, j + 1);
     }
-    ///White Cell
-    ///Try to place every possible no
+    /// White Cell
+    /// Try to place every possible no
     for (int no = 1; no <= 9; no++)
     {
         if (isPossible(mat, i, j, no))
         {
-            ///Place the no - assuming solution aa jayega
+            /// Place the no - assuming solution aa jayega
             mat[i][j] = no;
             bool aageKiSolveHui = solveSudoku(mat, i, j + 1);
             if (aageKiSolveHui)
             {
                 return true;
             }
-            ///Nahin solve hui
-            ///loop will place the next no.
+            /// Nahin solve hui
+            /// loop will place the next no.
         }
     }
-    ///Sare no try kr liey, kisi se bhi solve nahi hui
+    /// Sare no try kr liey, kisi se bhi solve nahi hui
     mat[i][j] = 0;
     return false;
 }
 
 int main()
 {
-
-    int mat[9][9] =
-        {{5, 3, 0, 0, 7, 0, 0, 0, 0},
-         {6, 0, 0, 1, 9, 5, 0, 0, 0},
-         {0, 9, 8, 0, 0, 0, 0, 6, 0},
-         {8, 0, 0, 0, 6, 0, 0, 0, 3},
-         {4, 0, 0, 8, 0, 3, 0, 0, 1},
-         {7, 0, 0, 0, 2, 0, 0, 0, 6},
-         {0, 6, 0, 0, 0, 0, 2, 8, 0},
-         {0, 0, 0, 4, 1, 9, 0, 0, 5},
-         {0, 0, 0, 0, 8, 0, 0, 7, 9}};
+    int mat[9][9] = {{5, 3, 0, 0, 7, 0, 0, 0, 0}, {6, 0, 0, 1, 9, 5, 0, 0, 0},
+                     {0, 9, 8, 0, 0, 0, 0, 6, 0}, {8, 0, 0, 0, 6, 0, 0, 0, 3},
+                     {4, 0, 0, 8, 0, 3, 0, 0, 1}, {7, 0, 0, 0, 2, 0, 0, 0, 6},
+                     {0, 6, 0, 0, 0, 0, 2, 8, 0}, {0, 0, 0, 4, 1, 9, 0, 0, 5},
+                     {0, 0, 0, 0, 8, 0, 0, 7, 9}};
 
     printMat(mat);
     cout << "Solution " << endl;
diff --git a/computer_oriented_statistical_methods/bisection_method.cpp b/computer_oriented_statistical_methods/bisection_method.cpp
index c93c529d2..ea0a5e931 100644
--- a/computer_oriented_statistical_methods/bisection_method.cpp
+++ b/computer_oriented_statistical_methods/bisection_method.cpp
@@ -23,29 +23,36 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i) {
+static double eq(double i)
+{
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
 /** get the sign of any given number */
 template <typename T>
-int sgn(T val) {
+int sgn(T val)
+{
     return (T(0) < val) - (val < T(0));
 }
 
 /** main function */
-int main() {
+int main()
+{
     double a = -1, b = 1, x, z;
     int i;
 
     // loop to find initial intervals a, b
-    for (int i = 0; i < MAX_ITERATIONS; i++) {
+    for (int i = 0; i < MAX_ITERATIONS; i++)
+    {
         z = eq(a);
         x = eq(b);
-        if (sgn(z) == sgn(x)) {  // same signs, increase interval
+        if (sgn(z) == sgn(x))
+        {  // same signs, increase interval
             b++;
             a--;
-        } else {  // if opposite signs, we got our interval
+        }
+        else
+        {  // if opposite signs, we got our interval
             break;
         }
     }
@@ -54,15 +61,19 @@ int main() {
     std::cout << "\nSecond initial: " << b;
 
     // start iterations
-    for (i = 0; i < MAX_ITERATIONS; i++) {
+    for (i = 0; i < MAX_ITERATIONS; i++)
+    {
         x = (a + b) / 2;
         z = eq(x);
         std::cout << "\n\nz: " << z << "\t[" << a << " , " << b
                   << " | Bisect: " << x << "]";
 
-        if (z < 0) {
+        if (z < 0)
+        {
             a = x;
-        } else {
+        }
+        else
+        {
             b = x;
         }
 
diff --git a/computer_oriented_statistical_methods/false_position.cpp b/computer_oriented_statistical_methods/false_position.cpp
index aebd154bb..6bdc0cf67 100644
--- a/computer_oriented_statistical_methods/false_position.cpp
+++ b/computer_oriented_statistical_methods/false_position.cpp
@@ -25,29 +25,36 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i) {
+static double eq(double i)
+{
     return (std::pow(i, 3) - (4 * i) - 9);  // origial equation
 }
 
 /** get the sign of any given number */
 template <typename T>
-int sgn(T val) {
+int sgn(T val)
+{
     return (T(0) < val) - (val < T(0));
 }
 
 /** main function */
-int main() {
+int main()
+{
     double a = -1, b = 1, x, z, m, n, c;
     int i;
 
     // loop to find initial intervals a, b
-    for (int i = 0; i < MAX_ITERATIONS; i++) {
+    for (int i = 0; i < MAX_ITERATIONS; i++)
+    {
         z = eq(a);
         x = eq(b);
-        if (sgn(z) == sgn(x)) {  // same signs, increase interval
+        if (sgn(z) == sgn(x))
+        {  // same signs, increase interval
             b++;
             a--;
-        } else {  // if opposite signs, we got our interval
+        }
+        else
+        {  // if opposite signs, we got our interval
             break;
         }
     }
@@ -55,7 +62,8 @@ int main() {
     std::cout << "\nFirst initial: " << a;
     std::cout << "\nSecond initial: " << b;
 
-    for (i = 0; i < MAX_ITERATIONS; i++) {
+    for (i = 0; i < MAX_ITERATIONS; i++)
+    {
         m = eq(a);
         n = eq(b);
 
@@ -64,7 +72,8 @@ int main() {
         a = c;
         z = eq(c);
 
-        if (std::abs(z) < EPSILON) {  // stoping criteria
+        if (std::abs(z) < EPSILON)
+        {  // stoping criteria
             break;
         }
     }
diff --git a/computer_oriented_statistical_methods/gaussian_elimination.cpp b/computer_oriented_statistical_methods/gaussian_elimination.cpp
index 60b5648ec..01cb578b2 100644
--- a/computer_oriented_statistical_methods/gaussian_elimination.cpp
+++ b/computer_oriented_statistical_methods/gaussian_elimination.cpp
@@ -6,7 +6,8 @@
 #include <iostream>
 
 /** Main function */
-int main() {
+int main()
+{
     int mat_size, i, j, step;
 
     std::cout << "Matrix size: ";
@@ -14,7 +15,8 @@ int main() {
 
     // create a 2D matrix by dynamic memory allocation
     double **mat = new double *[mat_size + 1], **x = new double *[mat_size];
-    for (i = 0; i <= mat_size; i++) {
+    for (i = 0; i <= mat_size; i++)
+    {
         mat[i] = new double[mat_size + 1];
         if (i < mat_size)
             x[i] = new double[mat_size + 1];
@@ -22,16 +24,20 @@ int main() {
 
     // get the matrix elements from user
     std::cout << std::endl << "Enter value of the matrix: " << std::endl;
-    for (i = 0; i < mat_size; i++) {
-        for (j = 0; j <= mat_size; j++) {
+    for (i = 0; i < mat_size; i++)
+    {
+        for (j = 0; j <= mat_size; j++)
+        {
             std::cin >>
                 mat[i][j];  // Enter (mat_size*mat_size) value of the matrix.
         }
     }
 
     // perform Gaussian elimination
-    for (step = 0; step < mat_size - 1; step++) {
-        for (i = step; i < mat_size - 1; i++) {
+    for (step = 0; step < mat_size - 1; step++)
+    {
+        for (i = step; i < mat_size - 1; i++)
+        {
             double a = (mat[i + 1][step] / mat[step][step]);
 
             for (j = step; j <= mat_size; j++)
@@ -41,8 +47,10 @@ int main() {
 
     std::cout << std::endl
               << "Matrix using Gaussian Elimination method: " << std::endl;
-    for (i = 0; i < mat_size; i++) {
-        for (j = 0; j <= mat_size; j++) {
+    for (i = 0; i < mat_size; i++)
+    {
+        for (j = 0; j <= mat_size; j++)
+        {
             x[i][j] = mat[i][j];
             std::cout << mat[i][j] << " ";
         }
@@ -50,9 +58,11 @@ int main() {
     }
     std::cout << std::endl
               << "Value of the Gaussian Elimination method: " << std::endl;
-    for (i = mat_size - 1; i >= 0; i--) {
+    for (i = mat_size - 1; i >= 0; i--)
+    {
         double sum = 0;
-        for (j = mat_size - 1; j > i; j--) {
+        for (j = mat_size - 1; j > i; j--)
+        {
             x[i][j] = x[j][j] * x[i][j];
             sum = x[i][j] + sum;
         }
@@ -64,7 +74,8 @@ int main() {
         std::cout << "x" << i << "= " << x[i][i] << std::endl;
     }
 
-    for (i = 0; i <= mat_size; i++) {
+    for (i = 0; i <= mat_size; i++)
+    {
         delete[] mat[i];
         if (i < mat_size)
             delete[] x[i];
diff --git a/computer_oriented_statistical_methods/newton_raphson_method.cpp b/computer_oriented_statistical_methods/newton_raphson_method.cpp
index 318363a39..a93774b91 100644
--- a/computer_oriented_statistical_methods/newton_raphson_method.cpp
+++ b/computer_oriented_statistical_methods/newton_raphson_method.cpp
@@ -21,18 +21,21 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i) {
+static double eq(double i)
+{
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
 /** define the derivative function \f$f'(x)\f$
  */
-static double eq_der(double i) {
+static double eq_der(double i)
+{
     return ((3 * std::pow(i, 2)) - 4);  // derivative of equation
 }
 
 /** Main function */
-int main() {
+int main()
+{
     std::srand(std::time(nullptr));  // initialize randomizer
 
     double z, c = std::rand() % 100, m, n;
@@ -41,7 +44,8 @@ int main() {
     std::cout << "\nInitial approximation: " << c;
 
     // start iterations
-    for (i = 0; i < MAX_ITERATIONS; i++) {
+    for (i = 0; i < MAX_ITERATIONS; i++)
+    {
         m = eq(c);
         n = eq_der(c);
 
diff --git a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
index de02b27bb..c3fe8be03 100644
--- a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
+++ b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
@@ -16,11 +16,13 @@
  */
 template <typename T>
 std::ostream &operator<<(std::ostream &out,
-                         std::vector<std::vector<T>> const &v) {
+                         std::vector<std::vector<T>> const &v)
+{
     const int width = 10;
     const char separator = ' ';
 
-    for (size_t row = 0; row < v.size(); row++) {
+    for (size_t row = 0; row < v.size(); row++)
+    {
         for (size_t col = 0; col < v[row].size(); col++)
             out << std::left << std::setw(width) << std::setfill(separator)
                 << v[row][col];
@@ -34,7 +36,8 @@ std::ostream &operator<<(std::ostream &out,
  * operator to print a vector
  */
 template <typename T>
-std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
+std::ostream &operator<<(std::ostream &out, std::vector<T> const &v)
+{
     const int width = 15;
     const char separator = ' ';
 
@@ -50,7 +53,8 @@ std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
  * \returns 1 if true, 0 if false
  */
 template <typename T>
-inline bool is_square(std::vector<std::vector<T>> const &A) {
+inline bool is_square(std::vector<std::vector<T>> const &A)
+{
     // Assuming A is square matrix
     size_t N = A.size();
     for (size_t i = 0; i < N; i++)
@@ -68,7 +72,8 @@ inline bool is_square(std::vector<std::vector<T>> const &A) {
  **/
 template <typename T>
 std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
-                                      std::vector<std::vector<T>> const &B) {
+                                      std::vector<std::vector<T>> const &B)
+{
     // Number of rows in A
     size_t N_A = A.size();
     // Number of columns in B
@@ -76,15 +81,18 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
 
     std::vector<std::vector<T>> result(N_A);
 
-    if (A[0].size() != B.size()) {
+    if (A[0].size() != B.size())
+    {
         std::cerr << "Number of columns in A != Number of rows in B ("
                   << A[0].size() << ", " << B.size() << ")" << std::endl;
         return result;
     }
 
-    for (size_t row = 0; row < N_A; row++) {
+    for (size_t row = 0; row < N_A; row++)
+    {
         std::vector<T> v(N_B);
-        for (size_t col = 0; col < N_B; col++) {
+        for (size_t col = 0; col < N_B; col++)
+        {
             v[col] = static_cast<T>(0);
             for (size_t j = 0; j < B.size(); j++)
                 v[col] += A[row][j] * B[j][col];
@@ -101,19 +109,22 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
  */
 template <typename T>
 std::vector<T> operator*(std::vector<std::vector<T>> const &A,
-                         std::vector<T> const &B) {
+                         std::vector<T> const &B)
+{
     // Number of rows in A
     size_t N_A = A.size();
 
     std::vector<T> result(N_A);
 
-    if (A[0].size() != B.size()) {
+    if (A[0].size() != B.size())
+    {
         std::cerr << "Number of columns in A != Number of rows in B ("
                   << A[0].size() << ", " << B.size() << ")" << std::endl;
         return result;
     }
 
-    for (size_t row = 0; row < N_A; row++) {
+    for (size_t row = 0; row < N_A; row++)
+    {
         result[row] = static_cast<T>(0);
         for (size_t j = 0; j < B.size(); j++) result[row] += A[row][j] * B[j];
     }
@@ -126,13 +137,15 @@ std::vector<T> operator*(std::vector<std::vector<T>> const &A,
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
+std::vector<float> operator*(float const scalar, std::vector<T> const &A)
+{
     // Number of rows in A
     size_t N_A = A.size();
 
     std::vector<float> result(N_A);
 
-    for (size_t row = 0; row < N_A; row++) {
+    for (size_t row = 0; row < N_A; row++)
+    {
         result[row] += A[row] * static_cast<float>(scalar);
     }
 
@@ -144,7 +157,8 @@ std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
+std::vector<float> operator*(std::vector<T> const &A, float const scalar)
+{
     // Number of rows in A
     size_t N_A = A.size();
 
@@ -161,7 +175,8 @@ std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
+std::vector<float> operator/(std::vector<T> const &A, float const scalar)
+{
     return (1.f / scalar) * A;
 }
 
@@ -170,13 +185,15 @@ std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
+std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B)
+{
     // Number of rows in A
     size_t N = A.size();
 
     std::vector<T> result(N);
 
-    if (B.size() != N) {
+    if (B.size() != N)
+    {
         std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
         return A;
     }
@@ -191,13 +208,15 @@ std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
  * \returns resultant vector
  */
 template <typename T>
-std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
+std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B)
+{
     // Number of rows in A
     size_t N = A.size();
 
     std::vector<T> result(N);
 
-    if (B.size() != N) {
+    if (B.size() != N)
+    {
         std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
         return A;
     }
@@ -214,26 +233,30 @@ std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
  **/
 template <typename T>
 std::vector<std::vector<float>> get_inverse(
-    std::vector<std::vector<T>> const &A) {
+    std::vector<std::vector<T>> const &A)
+{
     // Assuming A is square matrix
     size_t N = A.size();
 
     std::vector<std::vector<float>> inverse(N);
-    for (size_t row = 0; row < N; row++) {
+    for (size_t row = 0; row < N; row++)
+    {
         // preallocatae a resultant identity matrix
         inverse[row] = std::vector<float>(N);
         for (size_t col = 0; col < N; col++)
             inverse[row][col] = (row == col) ? 1.f : 0.f;
     }
 
-    if (!is_square(A)) {
+    if (!is_square(A))
+    {
         std::cerr << "A must be a square matrix!" << std::endl;
         return inverse;
     }
 
     // preallocatae a temporary matrix identical to A
     std::vector<std::vector<float>> temp(N);
-    for (size_t row = 0; row < N; row++) {
+    for (size_t row = 0; row < N; row++)
+    {
         std::vector<float> v(N);
         for (size_t col = 0; col < N; col++)
             v[col] = static_cast<float>(A[row][col]);
@@ -241,22 +264,27 @@ std::vector<std::vector<float>> get_inverse(
     }
 
     // start transformations
-    for (size_t row = 0; row < N; row++) {
-        for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++) {
+    for (size_t row = 0; row < N; row++)
+    {
+        for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++)
+        {
             // this to ensure diagonal elements are not 0
             temp[row] = temp[row] + temp[row2];
             inverse[row] = inverse[row] + inverse[row2];
         }
 
-        for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++) {
+        for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++)
+        {
             // this to further ensure diagonal elements are not 0
-            for (size_t row2 = 0; row2 < N; row2++) {
+            for (size_t row2 = 0; row2 < N; row2++)
+            {
                 temp[row2][row] = temp[row2][row] + temp[row2][col2];
                 inverse[row2][row] = inverse[row2][row] + inverse[row2][col2];
             }
         }
 
-        if (temp[row][row] == 0) {
+        if (temp[row][row] == 0)
+        {
             // Probably a low-rank matrix and hence singular
             std::cerr << "Low-rank matrix, no inverse!" << std::endl;
             return inverse;
@@ -267,7 +295,8 @@ std::vector<std::vector<float>> get_inverse(
         temp[row] = temp[row] / divisor;
         inverse[row] = inverse[row] / divisor;
         // Row transformations
-        for (size_t row2 = 0; row2 < N; row2++) {
+        for (size_t row2 = 0; row2 < N; row2++)
+        {
             if (row2 == row)
                 continue;
             float factor = temp[row2][row];
@@ -284,11 +313,12 @@ std::vector<std::vector<float>> get_inverse(
  * \returns resultant matrix
  **/
 template <typename T>
-std::vector<std::vector<T>> get_transpose(
-    std::vector<std::vector<T>> const &A) {
+std::vector<std::vector<T>> get_transpose(std::vector<std::vector<T>> const &A)
+{
     std::vector<std::vector<T>> result(A[0].size());
 
-    for (size_t row = 0; row < A[0].size(); row++) {
+    for (size_t row = 0; row < A[0].size(); row++)
+    {
         std::vector<T> v(A.size());
         for (size_t col = 0; col < A.size(); col++) v[col] = A[col][row];
 
@@ -306,7 +336,8 @@ std::vector<std::vector<T>> get_transpose(
  */
 template <typename T>
 std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
-                                     std::vector<T> const &Y) {
+                                     std::vector<T> const &Y)
+{
     // NxF
     std::vector<std::vector<T>> X2 = X;
     for (size_t i = 0; i < X2.size(); i++)
@@ -337,10 +368,12 @@ std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
 template <typename T>
 std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
                                          std::vector<float> const &beta /**< */
-) {
+)
+{
     std::vector<float> result(X.size());
 
-    for (size_t rows = 0; rows < X.size(); rows++) {
+    for (size_t rows = 0; rows < X.size(); rows++)
+    {
         // -> start with constant term
         result[rows] = beta[X[0].size()];
         for (size_t cols = 0; cols < X[0].size(); cols++)
@@ -353,7 +386,8 @@ std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
 /**
  * main function
  */
-int main() {
+int main()
+{
     size_t N, F;
 
     std::cout << "Enter number of features: ";
@@ -370,7 +404,8 @@ int main() {
         << "Enter training data. Per sample, provide features ad one output."
         << std::endl;
 
-    for (size_t rows = 0; rows < N; rows++) {
+    for (size_t rows = 0; rows < N; rows++)
+    {
         std::vector<float> v(F);
         std::cout << "Sample# " << rows + 1 << ": ";
         for (size_t cols = 0; cols < F; cols++)
@@ -391,7 +426,8 @@ int main() {
     std::vector<std::vector<float>> data2(T);
     // vector<float> Y2(T);
 
-    for (size_t rows = 0; rows < T; rows++) {
+    for (size_t rows = 0; rows < T; rows++)
+    {
         std::cout << "Sample# " << rows + 1 << ": ";
         std::vector<float> v(F);
         for (size_t cols = 0; cols < F; cols++) std::cin >> v[cols];
diff --git a/computer_oriented_statistical_methods/successive_approximation.cpp b/computer_oriented_statistical_methods/successive_approximation.cpp
index 351382f24..137933591 100644
--- a/computer_oriented_statistical_methods/successive_approximation.cpp
+++ b/computer_oriented_statistical_methods/successive_approximation.cpp
@@ -17,11 +17,13 @@ static float eq(float y) { return (3 * y) - cos(y) - 2; }
 static float eqd(float y) { return 0.5 * (cos(y) + 2); }
 
 /** Main function */
-int main() {
+int main()
+{
     float y, x1, x2, x3, sum, s, a, f1, f2, gd;
     int i, n;
 
-    for (i = 0; i < 10; i++) {
+    for (i = 0; i < 10; i++)
+    {
         sum = eq(y);
         std::cout << "value of equation at " << i << " " << sum << "\n";
         y++;
@@ -31,7 +33,8 @@ int main() {
     std::cout << "enter the no iteration to perform->\n";
     std::cin >> n;
 
-    for (i = 0; i <= n; i++) {
+    for (i = 0; i <= n; i++)
+    {
         x2 = eqd(x1);
         std::cout << "\nenter the x2->" << x2;
         x1 = x2;
diff --git a/data_structure/avltree.cpp b/data_structure/avltree.cpp
index db6b9e0d4..dc96ad977 100644
--- a/data_structure/avltree.cpp
+++ b/data_structure/avltree.cpp
@@ -5,172 +5,165 @@ using namespace std;
 
 typedef struct node
 {
-	int data;
-	int height;
-	struct node *left;
-	struct node *right;
+    int data;
+    int height;
+    struct node *left;
+    struct node *right;
 } node;
 
-int max(int a, int b)
-{
-	return a > b ? a : b;
-}
+int max(int a, int b) { return a > b ? a : b; }
 
 // Returns a new Node
 
 node *createNode(int data)
 {
-	node *nn = new node();
-	nn->data = data;
-	nn->height = 0;
-	nn->left = NULL;
-	nn->right = NULL;
-	return nn;
+    node *nn = new node();
+    nn->data = data;
+    nn->height = 0;
+    nn->left = NULL;
+    nn->right = NULL;
+    return nn;
 }
 
 // Returns height of tree
 
 int height(node *root)
 {
-	if (root == NULL)
-		return 0;
-	return 1 + max(height(root->left), height(root->right));
+    if (root == NULL)
+        return 0;
+    return 1 + max(height(root->left), height(root->right));
 }
 
 // Returns difference between height of left and right subtree
 
-int getBalance(node *root)
-{
-	return height(root->left) - height(root->right);
-}
+int getBalance(node *root) { return height(root->left) - height(root->right); }
 
 // Returns Node after Right Rotation
 
 node *rightRotate(node *root)
 {
-	node *t = root->left;
-	node *u = t->right;
-	t->right = root;
-	root->left = u;
-	return t;
+    node *t = root->left;
+    node *u = t->right;
+    t->right = root;
+    root->left = u;
+    return t;
 }
 
 // Returns Node after Left Rotation
 
 node *leftRotate(node *root)
 {
-	node *t = root->right;
-	node *u = t->left;
-	t->left = root;
-	root->right = u;
-	return t;
+    node *t = root->right;
+    node *u = t->left;
+    t->left = root;
+    root->right = u;
+    return t;
 }
 
 // Returns node with minimum value in the tree
 
 node *minValue(node *root)
 {
-	if (root->left == NULL)
-		return root;
-	return minValue(root->left);
+    if (root->left == NULL)
+        return root;
+    return minValue(root->left);
 }
 
 // Balanced Insertion
 
 node *insert(node *root, int item)
 {
-	node *nn = createNode(item);
-	if (root == NULL)
-		return nn;
-	if (item < root->data)
-		root->left = insert(root->left, item);
-	else
-		root->right = insert(root->right, item);
-	int b = getBalance(root);
-	if (b > 1)
-	{
-		if (getBalance(root->left) < 0)
-			root->left = leftRotate(root->left); // Left-Right Case
-		return rightRotate(root);				 // Left-Left Case
-	}
-	else if (b < -1)
-	{
-		if (getBalance(root->right) > 0)
-			root->right = rightRotate(root->right); // Right-Left Case
-		return leftRotate(root);					// Right-Right Case
-	}
-	return root;
+    node *nn = createNode(item);
+    if (root == NULL)
+        return nn;
+    if (item < root->data)
+        root->left = insert(root->left, item);
+    else
+        root->right = insert(root->right, item);
+    int b = getBalance(root);
+    if (b > 1)
+    {
+        if (getBalance(root->left) < 0)
+            root->left = leftRotate(root->left);  // Left-Right Case
+        return rightRotate(root);                 // Left-Left Case
+    }
+    else if (b < -1)
+    {
+        if (getBalance(root->right) > 0)
+            root->right = rightRotate(root->right);  // Right-Left Case
+        return leftRotate(root);                     // Right-Right Case
+    }
+    return root;
 }
 
 // Balanced Deletion
 
 node *deleteNode(node *root, int key)
 {
-	if (root == NULL)
-		return root;
-	if (key < root->data)
-		root->left = deleteNode(root->left, key);
-	else if (key > root->data)
-		root->right = deleteNode(root->right, key);
+    if (root == NULL)
+        return root;
+    if (key < root->data)
+        root->left = deleteNode(root->left, key);
+    else if (key > root->data)
+        root->right = deleteNode(root->right, key);
 
-	else
-	{
-		// Node to be deleted is leaf node or have only one Child
-		if (!root->right)
-		{
-			node *temp = root->left;
-			delete (root);
-			root = NULL;
-			return temp;
-		}
-		else if (!root->left)
-		{
-			node *temp = root->right;
-			delete (root);
-			root = NULL;
-			return temp;
-		}
-		// Node to be deleted have both left and right subtrees
-		node *temp = minValue(root->right);
-		root->data = temp->data;
-		root->right = deleteNode(root->right, temp->data);
-	}
-	// Balancing Tree after deletion
-	return root;
+    else
+    {
+        // Node to be deleted is leaf node or have only one Child
+        if (!root->right)
+        {
+            node *temp = root->left;
+            delete (root);
+            root = NULL;
+            return temp;
+        }
+        else if (!root->left)
+        {
+            node *temp = root->right;
+            delete (root);
+            root = NULL;
+            return temp;
+        }
+        // Node to be deleted have both left and right subtrees
+        node *temp = minValue(root->right);
+        root->data = temp->data;
+        root->right = deleteNode(root->right, temp->data);
+    }
+    // Balancing Tree after deletion
+    return root;
 }
 
 // LevelOrder (Breadth First Search)
 
 void levelOrder(node *root)
 {
-	queue<node *> q;
-	q.push(root);
-	while (!q.empty())
-	{
-		root = q.front();
-		cout << root->data << " ";
-		q.pop();
-		if (root->left)
-			q.push(root->left);
-		if (root->right)
-			q.push(root->right);
-	}
+    queue<node *> q;
+    q.push(root);
+    while (!q.empty())
+    {
+        root = q.front();
+        cout << root->data << " ";
+        q.pop();
+        if (root->left)
+            q.push(root->left);
+        if (root->right)
+            q.push(root->right);
+    }
 }
 
 int main()
 {
-	// Testing AVL Tree
-	node *root = NULL;
-	int i;
-	for (i = 1; i <= 7; i++)
-		root = insert(root, i);
-	cout << "LevelOrder: ";
-	levelOrder(root);
-	root = deleteNode(root, 1); // Deleting key with value 1
-	cout << "\nLevelOrder: ";
-	levelOrder(root);
-	root = deleteNode(root, 4); // Deletin key with value 4
-	cout << "\nLevelOrder: ";
-	levelOrder(root);
-	return 0;
+    // Testing AVL Tree
+    node *root = NULL;
+    int i;
+    for (i = 1; i <= 7; i++) root = insert(root, i);
+    cout << "LevelOrder: ";
+    levelOrder(root);
+    root = deleteNode(root, 1);  // Deleting key with value 1
+    cout << "\nLevelOrder: ";
+    levelOrder(root);
+    root = deleteNode(root, 4);  // Deletin key with value 4
+    cout << "\nLevelOrder: ";
+    levelOrder(root);
+    return 0;
 }
diff --git a/data_structure/binary_search_tree.cpp b/data_structure/binary_search_tree.cpp
index 32a65517c..ea9df12d3 100644
--- a/data_structure/binary_search_tree.cpp
+++ b/data_structure/binary_search_tree.cpp
@@ -3,216 +3,210 @@ using namespace std;
 
 struct node
 {
-	int val;
-	node *left;
-	node *right;
+    int val;
+    node *left;
+    node *right;
 };
 
 struct queue
 {
-	node *t[100];
-	int front;
-	int rear;
+    node *t[100];
+    int front;
+    int rear;
 };
 
 queue q;
 
-void enqueue(node *n)
-{
-	q.t[q.rear++] = n;
-}
+void enqueue(node *n) { q.t[q.rear++] = n; }
 
-node *dequeue()
-{
-	return (q.t[q.front++]);
-}
+node *dequeue() { return (q.t[q.front++]); }
 
 void Insert(node *n, int x)
 {
-	if (x < n->val)
-	{
-		if (n->left == NULL)
-		{
-			node *temp = new node;
-			temp->val = x;
-			temp->left = NULL;
-			temp->right = NULL;
-			n->left = temp;
-		}
-		else
-		{
-			Insert(n->left, x);
-		}
-	}
-	else
-	{
-		if (n->right == NULL)
-		{
-			node *temp = new node;
-			temp->val = x;
-			temp->left = NULL;
-			temp->right = NULL;
-			n->left = temp;
-		}
-		else
-		{
-			Insert(n->right, x);
-		}
-	}
+    if (x < n->val)
+    {
+        if (n->left == NULL)
+        {
+            node *temp = new node;
+            temp->val = x;
+            temp->left = NULL;
+            temp->right = NULL;
+            n->left = temp;
+        }
+        else
+        {
+            Insert(n->left, x);
+        }
+    }
+    else
+    {
+        if (n->right == NULL)
+        {
+            node *temp = new node;
+            temp->val = x;
+            temp->left = NULL;
+            temp->right = NULL;
+            n->left = temp;
+        }
+        else
+        {
+            Insert(n->right, x);
+        }
+    }
 }
 
 int findMaxInLeftST(node *n)
 {
-	while (n->right != NULL)
-	{
-		n = n->right;
-	}
-	return n->val;
+    while (n->right != NULL)
+    {
+        n = n->right;
+    }
+    return n->val;
 }
 
 void Remove(node *p, node *n, int x)
 {
-	if (n->val == x)
-	{
-		if (n->right == NULL && n->left == NULL)
-		{
-			if (x < p->val)
-			{
-				p->right = NULL;
-			}
-			else
-			{
-				p->left = NULL;
-			}
-		}
-		else if (n->right == NULL)
-		{
-			if (x < p->val)
-			{
-				p->right = n->left;
-			}
-			else
-			{
-				p->left = n->left;
-			}
-		}
-		else if (n->left == NULL)
-		{
-			if (x < p->val)
-			{
-				p->right = n->right;
-			}
-			else
-			{
-				p->left = n->right;
-			}
-		}
-		else
-		{
-			int y = findMaxInLeftST(n->left);
-			n->val = y;
-			Remove(n, n->right, y);
-		}
-	}
-	else if (x < n->val)
-	{
-		Remove(n, n->left, x);
-	}
-	else
-	{
-		Remove(n, n->right, x);
-	}
+    if (n->val == x)
+    {
+        if (n->right == NULL && n->left == NULL)
+        {
+            if (x < p->val)
+            {
+                p->right = NULL;
+            }
+            else
+            {
+                p->left = NULL;
+            }
+        }
+        else if (n->right == NULL)
+        {
+            if (x < p->val)
+            {
+                p->right = n->left;
+            }
+            else
+            {
+                p->left = n->left;
+            }
+        }
+        else if (n->left == NULL)
+        {
+            if (x < p->val)
+            {
+                p->right = n->right;
+            }
+            else
+            {
+                p->left = n->right;
+            }
+        }
+        else
+        {
+            int y = findMaxInLeftST(n->left);
+            n->val = y;
+            Remove(n, n->right, y);
+        }
+    }
+    else if (x < n->val)
+    {
+        Remove(n, n->left, x);
+    }
+    else
+    {
+        Remove(n, n->right, x);
+    }
 }
 
 void BFT(node *n)
 {
-	if (n != NULL)
-	{
-		cout << n->val << "  ";
-		enqueue(n->left);
-		enqueue(n->right);
-		BFT(dequeue());
-	}
+    if (n != NULL)
+    {
+        cout << n->val << "  ";
+        enqueue(n->left);
+        enqueue(n->right);
+        BFT(dequeue());
+    }
 }
 
 void Pre(node *n)
 {
-	if (n != NULL)
-	{
-		cout << n->val << "  ";
-		Pre(n->left);
-		Pre(n->right);
-	}
+    if (n != NULL)
+    {
+        cout << n->val << "  ";
+        Pre(n->left);
+        Pre(n->right);
+    }
 }
 
 void In(node *n)
 {
-	if (n != NULL)
-	{
-		In(n->left);
-		cout << n->val << "  ";
-		In(n->right);
-	}
+    if (n != NULL)
+    {
+        In(n->left);
+        cout << n->val << "  ";
+        In(n->right);
+    }
 }
 
 void Post(node *n)
 {
-	if (n != NULL)
-	{
-		Post(n->left);
-		Post(n->right);
-		cout << n->val << "  ";
-	}
+    if (n != NULL)
+    {
+        Post(n->left);
+        Post(n->right);
+        cout << n->val << "  ";
+    }
 }
 
 int main()
 {
-	q.front = 0;
-	q.rear = 0;
-	int value;
-	int ch;
-	node *root = new node;
-	cout << "\nEnter the value of root node :";
-	cin >> value;
-	root->val = value;
-	root->left = NULL;
-	root->right = NULL;
-	do
-	{
-		cout << "\n1. Insert";
-		cout << "\n2. Delete";
-		cout << "\n3. Breadth First";
-		cout << "\n4. Preorder Depth First";
-		cout << "\n5. Inorder Depth First";
-		cout << "\n6. Postorder Depth First";
+    q.front = 0;
+    q.rear = 0;
+    int value;
+    int ch;
+    node *root = new node;
+    cout << "\nEnter the value of root node :";
+    cin >> value;
+    root->val = value;
+    root->left = NULL;
+    root->right = NULL;
+    do
+    {
+        cout << "\n1. Insert";
+        cout << "\n2. Delete";
+        cout << "\n3. Breadth First";
+        cout << "\n4. Preorder Depth First";
+        cout << "\n5. Inorder Depth First";
+        cout << "\n6. Postorder Depth First";
 
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		int x;
-		switch (ch)
-		{
-		case 1:
-			cout << "\nEnter the value to be Inserted : ";
-			cin >> x;
-			Insert(root, x);
-			break;
-		case 2:
-			cout << "\nEnter the value to be Deleted : ";
-			cin >> x;
-			Remove(root, root, x);
-			break;
-		case 3:
-			BFT(root);
-			break;
-		case 4:
-			Pre(root);
-			break;
-		case 5:
-			In(root);
-			break;
-		case 6:
-			Post(root);
-			break;
-		}
-	} while (ch != 0);
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        int x;
+        switch (ch)
+        {
+        case 1:
+            cout << "\nEnter the value to be Inserted : ";
+            cin >> x;
+            Insert(root, x);
+            break;
+        case 2:
+            cout << "\nEnter the value to be Deleted : ";
+            cin >> x;
+            Remove(root, root, x);
+            break;
+        case 3:
+            BFT(root);
+            break;
+        case 4:
+            Pre(root);
+            break;
+        case 5:
+            In(root);
+            break;
+        case 6:
+            Post(root);
+            break;
+        }
+    } while (ch != 0);
 }
diff --git a/data_structure/binaryheap.cpp b/data_structure/binaryheap.cpp
index 31129a823..b2fc7d99c 100644
--- a/data_structure/binaryheap.cpp
+++ b/data_structure/binaryheap.cpp
@@ -1,6 +1,6 @@
 // A C++ program to demonstrate common Binary Heap Operations
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 // Prototype of a utility function to swap two integers
@@ -9,10 +9,10 @@ void swap(int *x, int *y);
 // A class for Min Heap
 class MinHeap
 {
-    int *harr;     // pointer to array of elements in heap
-    int capacity;  // maximum possible size of min heap
-    int heap_size; // Current number of elements in min heap
-public:
+    int *harr;      // pointer to array of elements in heap
+    int capacity;   // maximum possible size of min heap
+    int heap_size;  // Current number of elements in min heap
+ public:
     // Constructor
     MinHeap(int capacity);
 
diff --git a/data_structure/circular_queue_using_linked_list.cpp b/data_structure/circular_queue_using_linked_list.cpp
index 4b1ec476c..d87124448 100644
--- a/data_structure/circular_queue_using_linked_list.cpp
+++ b/data_structure/circular_queue_using_linked_list.cpp
@@ -11,7 +11,7 @@ class Queue
     node *front;
     node *rear;
 
-public:
+ public:
     Queue()
     {
         front = NULL;
diff --git a/data_structure/cll/cll.cpp b/data_structure/cll/cll.cpp
index efc068f3c..e9fcfc40b 100644
--- a/data_structure/cll/cll.cpp
+++ b/data_structure/cll/cll.cpp
@@ -11,10 +11,7 @@ cll::cll()
     total = 0;
 }
 
-cll::~cll()
-{
-    /* Desstructure, no need to fill */
-}
+cll::~cll() { /* Desstructure, no need to fill */ }
 
 /* Display a list. and total element */
 void cll::display()
@@ -28,10 +25,10 @@ void cll::display()
         for (int i = 0; i < total; i++)
         {
             cout << current->data << " -> ";
-            current = current ->next;
+            current = current->next;
         }
         cout << head->data << endl;
-        cout << "Total element: "<< total <<endl;
+        cout << "Total element: " << total << endl;
     }
 }
 
@@ -42,12 +39,16 @@ void cll::insert_front(int new_data)
     newNode = new node;
     newNode->data = new_data;
     newNode->next = NULL;
-    if(head==NULL) {
+    if (head == NULL)
+    {
         head = newNode;
-        head -> next = head;
-    } else {
+        head->next = head;
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
+        while (current->next != head)
+        {
             current = current->next;
         }
         newNode->next = head;
@@ -64,12 +65,16 @@ void cll::insert_tail(int new_data)
     newNode = new node;
     newNode->data = new_data;
     newNode->next = NULL;
-    if(head==NULL) {
+    if (head == NULL)
+    {
         head = newNode;
-        head -> next = head;
-    } else {
+        head->next = head;
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
+        while (current->next != head)
+        {
             current = current->next;
         }
         current->next = newNode;
@@ -79,22 +84,22 @@ void cll::insert_tail(int new_data)
 }
 
 /* Get total element in list */
-int cll::get_size()
-{
-    return total;
-}
-
+int cll::get_size() { return total; }
 
 /* Return true if the requested item (sent in as an argument)
 is in the list, otherwise return false */
 bool cll::find_item(int item_to_find)
 {
-    if (head == NULL) {
+    if (head == NULL)
+    {
         cout << "List is empty !" << endl;
         return false;
-    } else {
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
+        while (current->next != head)
+        {
             if (current->data == item_to_find)
                 return true;
             current = current->next;
@@ -104,24 +109,25 @@ bool cll::find_item(int item_to_find)
 }
 
 /* Overloading method*/
-int cll::operator*()
-{
-    return head->data;
-}
+int cll::operator*() { return head->data; }
 
 /* Overload the pre-increment operator.
    The iterator is advanced to the next node. */
 void cll::operator++()
 {
-    if (head == NULL) {
+    if (head == NULL)
+    {
         cout << "List is empty !" << endl;
-    } else {
+    }
+    else
+    {
         node *current = head;
-        while (current -> next != head) {
-            current = current -> next;
+        while (current->next != head)
+        {
+            current = current->next;
         }
-        current->next = head -> next;
-        head = head -> next;
+        current->next = head->next;
+        head = head->next;
     }
     total--;
 }
diff --git a/data_structure/cll/cll.h b/data_structure/cll/cll.h
index ae71dcd01..89a9fe199 100644
--- a/data_structure/cll/cll.h
+++ b/data_structure/cll/cll.h
@@ -1,45 +1,45 @@
 /*
  * Simple data structure CLL (Cicular Linear Linked List)
  * */
-#include <cstring>
 #include <cctype>
-#include <iostream>
 #include <cstdlib>
+#include <cstring>
+#include <iostream>
 
 #ifndef CLL_H
 #define CLL_H
 /*The data structure is a linear linked list of integers */
 struct node
 {
-	int  data;
-    node * next;
+    int data;
+    node* next;
 };
 
 class cll
 {
-    public:
-        cll();                       /* Construct without parameter */
-        ~cll();
-        void display();              /* Show the list */
+ public:
+    cll(); /* Construct without parameter */
+    ~cll();
+    void display(); /* Show the list */
 
-        /******************************************************
-	    * Useful method for list
-        *******************************************************/
-        void insert_front(int new_data);  /* Insert a new value at head  */
-		void insert_tail(int new_data);   /* Insert a new value at tail */
-		int get_size();              /* Get total element in list */
-        bool find_item(int item_to_find); /* Find an item in list */
+    /******************************************************
+     * Useful method for list
+     *******************************************************/
+    void insert_front(int new_data);  /* Insert a new value at head  */
+    void insert_tail(int new_data);   /* Insert a new value at tail */
+    int get_size();                   /* Get total element in list */
+    bool find_item(int item_to_find); /* Find an item in list */
 
-	    /******************************************************
-	     * Overloading method for list
-         *******************************************************/
-	     int operator*();           /* Returns the info contained in head */
-	     /* Overload the pre-increment operator.
-	        The iterator is advanced to the next node. */
-	     void operator++();
+    /******************************************************
+     * Overloading method for list
+     *******************************************************/
+    int operator*(); /* Returns the info contained in head */
+    /* Overload the pre-increment operator.
+       The iterator is advanced to the next node. */
+    void operator++();
 
-    protected:
-        node * head;
-		int total;      /* Total element in a list */
+ protected:
+    node* head;
+    int total; /* Total element in a list */
 };
 #endif
diff --git a/data_structure/cll/main_cll.cpp b/data_structure/cll/main_cll.cpp
index 15388b822..3876f0393 100644
--- a/data_structure/cll/main_cll.cpp
+++ b/data_structure/cll/main_cll.cpp
@@ -3,42 +3,42 @@ using namespace std;
 
 int main()
 {
-	/* Test CLL */
-	cout << "----------- Test construct -----------" << endl;
-	cll list1;
-	list1.display();
-	cout << "----------- Test insert front -----------" << endl;
-	list1.insert_front(5);
-	cout << "After insert 5 at front: "<<endl;
+    /* Test CLL */
+    cout << "----------- Test construct -----------" << endl;
+    cll list1;
+    list1.display();
+    cout << "----------- Test insert front -----------" << endl;
+    list1.insert_front(5);
+    cout << "After insert 5 at front: " << endl;
+    list1.display();
+    cout << "After insert 10 3 7 at front: " << endl;
+    list1.insert_front(10);
+    list1.insert_front(3);
+    list1.insert_front(7);
+    list1.display();
+    cout << "----------- Test insert tail -----------" << endl;
+    cout << "After insert 18 19 20 at tail: " << endl;
+    list1.insert_tail(18);
+    list1.insert_tail(19);
+    list1.insert_tail(20);
+    list1.display();
+    cout << "----------- Test find item -----------" << endl;
+    if (list1.find_item(10))
+        cout << "PASS" << endl;
+    else
+        cout << "FAIL" << endl;
+    if (!list1.find_item(30))
+        cout << "PASS" << endl;
+    else
+        cout << "FAIL" << endl;
+    cout << "----------- Test * operator -----------" << endl;
+    int value = *list1;
+    cout << "Value at *list1: " << value << endl;
+    cout << "----------- Test ++ operator -----------" << endl;
+    list1.display();
+    ++list1;
+    cout << "After ++list1: " << endl;
     list1.display();
-	cout << "After insert 10 3 7 at front: "<<endl;
-	list1.insert_front(10);
-	list1.insert_front(3);
-	list1.insert_front(7);
-	list1.display();
-	cout << "----------- Test insert tail -----------" << endl;
-	cout << "After insert 18 19 20 at tail: "<<endl;
-	list1.insert_tail(18);
-	list1.insert_tail(19);
-	list1.insert_tail(20);
-	list1.display();
-	cout << "----------- Test find item -----------" << endl;
-	if (list1.find_item(10))
-		cout << "PASS" << endl;
-	else
-		cout << "FAIL" << endl;
-	if (!list1.find_item(30))
-		cout << "PASS" << endl;
-	else
-		cout << "FAIL" << endl;
-	cout << "----------- Test * operator -----------" << endl;
-	int value = *list1;
-	cout << "Value at *list1: " << value <<endl;
-	cout << "----------- Test ++ operator -----------" << endl;
-	list1.display();
-	++list1;
-	cout << "After ++list1: " <<endl;
-	list1.display();
 
-	return 0;
+    return 0;
 }
diff --git a/data_structure/disjoint_set.cpp b/data_structure/disjoint_set.cpp
index 71b220ab9..8d27b704f 100644
--- a/data_structure/disjoint_set.cpp
+++ b/data_structure/disjoint_set.cpp
@@ -7,58 +7,72 @@ using std::vector;
 
 vector<int> root, rnk;
 
-void CreateSet(int n) {
-  root = vector<int> (n+1);
-  rnk = vector<int> (n+1, 1);
-  for (int i = 1; i <= n; ++i) {
-    root[i] = i;
-  }
-}
-
-int Find(int x) {
-  if (root[x] == x) {
-    return x;
-  }
-  return root[x] = Find(root[x]);
-}
-
-bool InSameUnion(int x, int y) {
-  return Find(x) == Find(y);
-}
-
-void Union(int x, int y) {
-  int a = Find(x), b = Find(y);
-  if (a != b) {
-    if (rnk[a] < rnk[b]) {
-      root[a] = b;
-    } else if (rnk[a] > rnk[b]) {
-      root[b] = a;
-    } else {
-      root[a] = b;
-      ++rnk[b];
+void CreateSet(int n)
+{
+    root = vector<int>(n + 1);
+    rnk = vector<int>(n + 1, 1);
+    for (int i = 1; i <= n; ++i)
+    {
+        root[i] = i;
     }
-  }
 }
 
-int main() {
-  // tests CreateSet & Find
-  int n = 100;
-  CreateSet(n);
-  for (int i = 1; i <= 100; ++i) {
-    if (root[i] != i) {
-      cout << "Fail" << endl;
-      break;
+int Find(int x)
+{
+    if (root[x] == x)
+    {
+        return x;
     }
-  }
-  // tests InSameUnion & Union
-  cout << "1 and 2 are initially not in the same subset" << endl;
-  if (InSameUnion(1, 2)) {
-    cout << "Fail" << endl;
-  }
-  Union(1, 2);
-  cout << "1 and 2 are now in the same subset" << endl;
-  if (!InSameUnion(1, 2)) {
-    cout << "Fail" << endl;
-  }
-  return 0;
+    return root[x] = Find(root[x]);
+}
+
+bool InSameUnion(int x, int y) { return Find(x) == Find(y); }
+
+void Union(int x, int y)
+{
+    int a = Find(x), b = Find(y);
+    if (a != b)
+    {
+        if (rnk[a] < rnk[b])
+        {
+            root[a] = b;
+        }
+        else if (rnk[a] > rnk[b])
+        {
+            root[b] = a;
+        }
+        else
+        {
+            root[a] = b;
+            ++rnk[b];
+        }
+    }
+}
+
+int main()
+{
+    // tests CreateSet & Find
+    int n = 100;
+    CreateSet(n);
+    for (int i = 1; i <= 100; ++i)
+    {
+        if (root[i] != i)
+        {
+            cout << "Fail" << endl;
+            break;
+        }
+    }
+    // tests InSameUnion & Union
+    cout << "1 and 2 are initially not in the same subset" << endl;
+    if (InSameUnion(1, 2))
+    {
+        cout << "Fail" << endl;
+    }
+    Union(1, 2);
+    cout << "1 and 2 are now in the same subset" << endl;
+    if (!InSameUnion(1, 2))
+    {
+        cout << "Fail" << endl;
+    }
+    return 0;
 }
diff --git a/data_structure/doubly_linked_list.cpp b/data_structure/doubly_linked_list.cpp
index 4fc38abfc..4907c125d 100644
--- a/data_structure/doubly_linked_list.cpp
+++ b/data_structure/doubly_linked_list.cpp
@@ -1,138 +1,166 @@
+#include <cstdio>
+#include <cstdlib>
 #include <iostream>
-#include<cstdio>
-#include<cstdlib>
 
-struct node {
-  int val;
-  node *prev;
-  node *next;
-}*start;
+struct node
+{
+    int val;
+    node *prev;
+    node *next;
+} * start;
 
-class double_linked_list {
+class double_linked_list
+{
  public:
-  double_linked_list() {
-    start = NULL;
-  }
-  void insert(int x);
-  void remove(int x);
-  void search(int x);
-  void show();
-  void reverseShow();
+    double_linked_list() { start = NULL; }
+    void insert(int x);
+    void remove(int x);
+    void search(int x);
+    void show();
+    void reverseShow();
 };
 
-void double_linked_list::insert(int x) {
-  node *t = start;
-  if (start != NULL) {
-    while (t->next != NULL) {
-      t = t->next;
+void double_linked_list::insert(int x)
+{
+    node *t = start;
+    if (start != NULL)
+    {
+        while (t->next != NULL)
+        {
+            t = t->next;
+        }
+        node *n = new node;
+        t->next = n;
+        n->prev = t;
+        n->val = x;
+        n->next = NULL;
     }
-    node *n = new node;
-    t->next = n;
-    n->prev = t;
-    n->val = x;
-    n->next = NULL;
-  } else {
-    node *n = new node;
-    n->val = x;
-    n->prev = NULL;
-    n->next = NULL;
-    start = n;
-  }
-}
-
-void double_linked_list::remove(int x) {
-  node *t = start;
-  while (t != NULL && t->val != x) {
-    t = t-> next;
-  }
-  if (t == NULL) {
-    return;
-  }
-  if (t->prev == NULL) {
-    if (t->next == NULL) {
-      start = NULL;
-    } else {
-      start = t->next;
-      start->prev = NULL;
+    else
+    {
+        node *n = new node;
+        n->val = x;
+        n->prev = NULL;
+        n->next = NULL;
+        start = n;
     }
-  } else if (t->next == NULL) {
-    t->prev->next = NULL;
-  } else {
-    t->prev->next = t->next;
-    t->next->prev = t->prev;
-  }
-  delete t;
 }
 
-void double_linked_list::search(int x) {
-  node *t = start;
-  int found = 0;
-  while (t != NULL) {
-    if (t->val == x) {
-      std::cout << "\nFound";
-      found = 1;
-      break;
+void double_linked_list::remove(int x)
+{
+    node *t = start;
+    while (t != NULL && t->val != x)
+    {
+        t = t->next;
     }
-    t = t->next;
-  }
-  if (found == 0) {
-    std::cout << "\nNot Found";
-  }
-}
-
-void double_linked_list::show() {
-  node *t = start;
-  while (t != NULL) {
-    std::cout << t->val << "\t";
-    t = t->next;
-  }
-}
-
-void double_linked_list::reverseShow() {
-  node *t = start;
-  while (t != NULL && t->next != NULL) {
-    t = t->next;
-  }
-  while (t != NULL) {
-    std::cout << t->val << "\t";
-    t = t->prev;
-  }
-}
-
-int main() {
-  int choice, x;
-  double_linked_list ob;
-  do {
-    std::cout << "\n1. Insert";
-    std::cout << "\n2. Delete";
-    std::cout << "\n3. Search";
-    std::cout << "\n4. Forward print";
-    std::cout << "\n5. Reverse print";
-    std::cout << "\n\nEnter you choice : ";
-    std::cin >> choice;
-    switch (choice) {
-      case 1:
-        std::cout << "\nEnter the element to be inserted : ";
-        std::cin >> x;
-        ob.insert(x);
-        break;
-      case 2:
-        std::cout << "\nEnter the element to be removed : ";
-        std::cin >> x;
-        ob.remove(x);
-        break;
-      case 3:
-        std::cout << "\nEnter the element to be searched : ";
-        std::cin >> x;
-        ob.search(x);
-        break;
-      case 4:
-        ob.show();
-        break;
-      case 5:
-        ob.reverseShow();
-        break;
+    if (t == NULL)
+    {
+        return;
     }
-  } while (choice != 0);
-  return 0;
+    if (t->prev == NULL)
+    {
+        if (t->next == NULL)
+        {
+            start = NULL;
+        }
+        else
+        {
+            start = t->next;
+            start->prev = NULL;
+        }
+    }
+    else if (t->next == NULL)
+    {
+        t->prev->next = NULL;
+    }
+    else
+    {
+        t->prev->next = t->next;
+        t->next->prev = t->prev;
+    }
+    delete t;
+}
+
+void double_linked_list::search(int x)
+{
+    node *t = start;
+    int found = 0;
+    while (t != NULL)
+    {
+        if (t->val == x)
+        {
+            std::cout << "\nFound";
+            found = 1;
+            break;
+        }
+        t = t->next;
+    }
+    if (found == 0)
+    {
+        std::cout << "\nNot Found";
+    }
+}
+
+void double_linked_list::show()
+{
+    node *t = start;
+    while (t != NULL)
+    {
+        std::cout << t->val << "\t";
+        t = t->next;
+    }
+}
+
+void double_linked_list::reverseShow()
+{
+    node *t = start;
+    while (t != NULL && t->next != NULL)
+    {
+        t = t->next;
+    }
+    while (t != NULL)
+    {
+        std::cout << t->val << "\t";
+        t = t->prev;
+    }
+}
+
+int main()
+{
+    int choice, x;
+    double_linked_list ob;
+    do
+    {
+        std::cout << "\n1. Insert";
+        std::cout << "\n2. Delete";
+        std::cout << "\n3. Search";
+        std::cout << "\n4. Forward print";
+        std::cout << "\n5. Reverse print";
+        std::cout << "\n\nEnter you choice : ";
+        std::cin >> choice;
+        switch (choice)
+        {
+        case 1:
+            std::cout << "\nEnter the element to be inserted : ";
+            std::cin >> x;
+            ob.insert(x);
+            break;
+        case 2:
+            std::cout << "\nEnter the element to be removed : ";
+            std::cin >> x;
+            ob.remove(x);
+            break;
+        case 3:
+            std::cout << "\nEnter the element to be searched : ";
+            std::cin >> x;
+            ob.search(x);
+            break;
+        case 4:
+            ob.show();
+            break;
+        case 5:
+            ob.reverseShow();
+            break;
+        }
+    } while (choice != 0);
+    return 0;
 }
diff --git a/data_structure/linked_list.cpp b/data_structure/linked_list.cpp
index 64cad14f9..f639bb16c 100644
--- a/data_structure/linked_list.cpp
+++ b/data_structure/linked_list.cpp
@@ -1,135 +1,160 @@
 #include <iostream>
 
-struct node {
-        int val;
-        node *next;
+struct node
+{
+    int val;
+    node *next;
 };
 
 node *start;
 
-void insert(int x) {
-        node *t = start;
-        node *n = new node;
-        n->val = x;
-        n->next = NULL;
-        if (start != NULL) {
-                while (t->next != NULL) {
-                        t = t->next;
-                }
-                t->next = n;             
-        } else {
-                start = n;
+void insert(int x)
+{
+    node *t = start;
+    node *n = new node;
+    n->val = x;
+    n->next = NULL;
+    if (start != NULL)
+    {
+        while (t->next != NULL)
+        {
+            t = t->next;
         }
-        
+        t->next = n;
+    }
+    else
+    {
+        start = n;
+    }
 }
 
-void remove(int x) {
-        if (start == NULL) {
-                std::cout << "\nLinked List is empty\n";
-                return;
-        } else if (start->val == x) {
-                node *temp = start;
-                start = start->next;
-                delete temp;
-                return;
-        }
-
-        node *temp = start, *parent = start;
-
-        while (temp != NULL && temp->val != x) {
-                parent = temp;
-                temp = temp->next;
-        }
-
-        if (temp == NULL) {
-                std::cout << std::endl << x << " not found in list\n";
-                return;
-        }
-
-        parent->next = temp->next;
+void remove(int x)
+{
+    if (start == NULL)
+    {
+        std::cout << "\nLinked List is empty\n";
+        return;
+    }
+    else if (start->val == x)
+    {
+        node *temp = start;
+        start = start->next;
         delete temp;
+        return;
+    }
+
+    node *temp = start, *parent = start;
+
+    while (temp != NULL && temp->val != x)
+    {
+        parent = temp;
+        temp = temp->next;
+    }
+
+    if (temp == NULL)
+    {
+        std::cout << std::endl << x << " not found in list\n";
+        return;
+    }
+
+    parent->next = temp->next;
+    delete temp;
 }
 
-void search(int x) {
-        node *t = start;
-        int found = 0;
-        while (t != NULL) {
-                if (t->val == x) {
-                        std::cout << "\nFound";
-                        found = 1;
-                        break;
-                }
-                t = t->next;
+void search(int x)
+{
+    node *t = start;
+    int found = 0;
+    while (t != NULL)
+    {
+        if (t->val == x)
+        {
+            std::cout << "\nFound";
+            found = 1;
+            break;
         }
-        if (found == 0) {
-                std::cout << "\nNot Found";
+        t = t->next;
+    }
+    if (found == 0)
+    {
+        std::cout << "\nNot Found";
+    }
+}
+
+void show()
+{
+    node *t = start;
+    while (t != NULL)
+    {
+        std::cout << t->val << "\t";
+        t = t->next;
+    }
+}
+
+void reverse()
+{
+    node *first = start;
+    if (first != NULL)
+    {
+        node *second = first->next;
+        while (second != NULL)
+        {
+            node *tem = second->next;
+            second->next = first;
+            first = second;
+            second = tem;
         }
+        start->next = NULL;
+        start = first;
+    }
+    else
+    {
+        std::cout << "\nEmpty list";
+    }
 }
 
-void show() {
-        node *t = start;
-        while (t != NULL) {
-                std::cout << t->val << "\t";
-                t = t->next;
+int main()
+{
+    int choice, x;
+    do
+    {
+        std::cout << "\n1. Insert";
+        std::cout << "\n2. Delete";
+        std::cout << "\n3. Search";
+        std::cout << "\n4. Print";
+        std::cout << "\n5. Reverse";
+        std::cout << "\n0. Exit";
+        std::cout << "\n\nEnter you choice : ";
+        std::cin >> choice;
+        switch (choice)
+        {
+        case 1:
+            std::cout << "\nEnter the element to be inserted : ";
+            std::cin >> x;
+            insert(x);
+            break;
+        case 2:
+            std::cout << "\nEnter the element to be removed : ";
+            std::cin >> x;
+            remove(x);
+            break;
+        case 3:
+            std::cout << "\nEnter the element to be searched : ";
+            std::cin >> x;
+            search(x);
+            break;
+        case 4:
+            show();
+            std::cout << "\n";
+            break;
+        case 5:
+            std::cout << "The reversed list: \n";
+            reverse();
+            show();
+            std::cout << "\n";
+            break;
         }
-}
+    } while (choice != 0);
 
-void reverse() {
-        node *first = start;
-        if (first != NULL) {
-                node *second = first->next;
-                while (second != NULL) {
-                        node *tem = second->next;
-                        second->next = first;
-                        first = second;
-                        second = tem;
-                }
-                start->next = NULL;
-                start = first;
-        } else {
-                std::cout << "\nEmpty list";
-        }
-}
-
-int main() {
-        int choice, x;
-        do {
-                std::cout << "\n1. Insert";
-                std::cout << "\n2. Delete";
-                std::cout << "\n3. Search";
-                std::cout << "\n4. Print";
-                std::cout << "\n5. Reverse";
-                std::cout << "\n0. Exit";
-                std::cout << "\n\nEnter you choice : ";
-                std::cin >> choice;
-                switch (choice) {
-                case 1:
-                        std::cout << "\nEnter the element to be inserted : ";
-                        std::cin >> x;
-                        insert(x);
-                        break;
-                case 2:
-                        std::cout << "\nEnter the element to be removed : ";
-                        std::cin >> x;
-                        remove(x);
-                        break;
-                 case 3:
-                        std::cout << "\nEnter the element to be searched : ";
-                        std::cin >> x;
-                        search(x);
-                        break;
-                 case 4:
-                        show();
-                        std::cout << "\n";
-                        break;
-                 case 5:
-                        std::cout << "The reversed list: \n";
-                        reverse();
-                        show();
-                        std::cout << "\n";
-                        break;
-               }
-        } while (choice != 0);
-
-        return 0;
+    return 0;
 }
diff --git a/data_structure/linkedlist_implentation_usingarray.cpp b/data_structure/linkedlist_implentation_usingarray.cpp
index 6f8205f27..168124f00 100644
--- a/data_structure/linkedlist_implentation_usingarray.cpp
+++ b/data_structure/linkedlist_implentation_usingarray.cpp
@@ -1,6 +1,8 @@
-/* The difference between the pointer implementation of linked list and array implementation of linked list:
+/* The difference between the pointer implementation of linked list and array
+ implementation of linked list:
  1. The NULL is represented by -1;
- 2. Limited size. (in the following case it is 100 nodes at max). But we can reuse the nodes that are to be deleted by again linking it bacj to the list.
+ 2. Limited size. (in the following case it is 100 nodes at max). But we can
+ reuse the nodes that are to be deleted by again linking it bacj to the list.
 */
 
 #include <iostream>
@@ -10,7 +12,7 @@ struct Node
     int data;
     int next;
 };
-Node AvailArray[100]; //array that will act as nodes of a linked list.
+Node AvailArray[100];  // array that will act as nodes of a linked list.
 int head = -1;
 int avail = 0;
 void initialise_list()
@@ -19,23 +21,28 @@ void initialise_list()
     {
         AvailArray[i].next = i + 1;
     }
-    AvailArray[99].next = -1; //indicating the end of the linked list.
+    AvailArray[99].next = -1;  // indicating the end of the linked list.
 }
 
-int getnode() //This will return the index of the first free node present in the avail list
+int getnode()  // This will return the index of the first free node present in
+               // the avail list
 {
     int NodeIndexToBeReturned = avail;
     avail = AvailArray[avail].next;
     return NodeIndexToBeReturned;
 }
 
-void freeNode(int nodeToBeDeleted) //This function when called will delete the node with the index presented as an argument, and will put back that node into the array.
+void freeNode(
+    int nodeToBeDeleted)  // This function when called will delete the node with
+                          // the index presented as an argument, and will put
+                          // back that node into the array.
 {
     AvailArray[nodeToBeDeleted].next = avail;
     avail = nodeToBeDeleted;
 }
 
-void insertAtTheBeginning(int data) //The function will insert the given data into the front of the linked list.
+void insertAtTheBeginning(int data)  // The function will insert the given data
+                                     // into the front of the linked list.
 {
     int newNode = getnode();
     AvailArray[newNode].data = data;
@@ -51,7 +58,7 @@ void insertAtTheEnd(int data)
     {
         temp = AvailArray[temp].next;
     }
-    //temp is now pointing to the end node.
+    // temp is now pointing to the end node.
     AvailArray[newNode].data = data;
     AvailArray[newNode].next = -1;
     AvailArray[temp].next = newNode;
@@ -94,7 +101,8 @@ int main()
             insertAtTheEnd(y);
             break;
         case 3:
-            cout << "The linked list contains the following element in order" << endl;
+            cout << "The linked list contains the following element in order"
+                 << endl;
             display();
             break;
         case 4:
diff --git a/data_structure/list_array.cpp b/data_structure/list_array.cpp
index de984876b..f572b77b4 100644
--- a/data_structure/list_array.cpp
+++ b/data_structure/list_array.cpp
@@ -3,186 +3,184 @@ using namespace std;
 
 struct list
 {
-	int data[50];
-	int top = 0;
-	bool isSorted = false;
+    int data[50];
+    int top = 0;
+    bool isSorted = false;
 
-	int BinarySearch(int *array, int first, int last, int x)
-	{
-		if (last < first)
-		{
-			return -1;
-		}
-		int mid = (first + last) / 2;
-		if (array[mid] == x)
-			return mid;
-		else if (x < array[mid])
-			return (BinarySearch(array, first, mid - 1, x));
-		else if (x > array[mid])
-			return (BinarySearch(array, mid + 1, last, x));
-	}
+    int BinarySearch(int *array, int first, int last, int x)
+    {
+        if (last < first)
+        {
+            return -1;
+        }
+        int mid = (first + last) / 2;
+        if (array[mid] == x)
+            return mid;
+        else if (x < array[mid])
+            return (BinarySearch(array, first, mid - 1, x));
+        else if (x > array[mid])
+            return (BinarySearch(array, mid + 1, last, x));
+    }
 
-	int LinarSearch(int *array, int x)
-	{
-		for (int i = 0; i < top; i++)
-		{
-			if (array[i] == x)
-			{
-				return i;
-			}
-		}
+    int LinarSearch(int *array, int x)
+    {
+        for (int i = 0; i < top; i++)
+        {
+            if (array[i] == x)
+            {
+                return i;
+            }
+        }
 
-		return -1;
-	}
+        return -1;
+    }
 
-	int Search(int x)
-	{
-		int pos = -1;
+    int Search(int x)
+    {
+        int pos = -1;
 
-		if (isSorted)
-		{
-			pos = BinarySearch(data, 0, top - 1, x);
-		}
+        if (isSorted)
+        {
+            pos = BinarySearch(data, 0, top - 1, x);
+        }
 
-		else
-		{
-			pos = LinarSearch(data, x);
-		}
+        else
+        {
+            pos = LinarSearch(data, x);
+        }
 
-		if (pos != -1)
-		{
-			cout << "\nElement found at position : " << pos;
-		}
-		else
-		{
-			cout << "\nElement not found";
-		}
-		return pos;
-	}
+        if (pos != -1)
+        {
+            cout << "\nElement found at position : " << pos;
+        }
+        else
+        {
+            cout << "\nElement not found";
+        }
+        return pos;
+    }
 
-	void Sort()
-	{
-		int i, j, pos;
-		for (i = 0; i < top; i++)
-		{
-			int min = data[i];
-			for (j = i + 1; j < top; j++)
-			{
-				if (data[j] < min)
-				{
-					pos = j;
-					min = data[pos];
-				}
-			}
+    void Sort()
+    {
+        int i, j, pos;
+        for (i = 0; i < top; i++)
+        {
+            int min = data[i];
+            for (j = i + 1; j < top; j++)
+            {
+                if (data[j] < min)
+                {
+                    pos = j;
+                    min = data[pos];
+                }
+            }
 
-			int temp = data[i];
-			data[i] = data[pos];
-			data[pos] = temp;
-		}
-		isSorted = true;
-	}
+            int temp = data[i];
+            data[i] = data[pos];
+            data[pos] = temp;
+        }
+        isSorted = true;
+    }
 
-	void insert(int x)
-	{
-		if (!isSorted)
-		{
+    void insert(int x)
+    {
+        if (!isSorted)
+        {
+            if (top == 49)
+            {
+                cout << "\nOverflow";
+            }
+            else
+            {
+                data[top] = x;
+                top++;
+            }
+        }
 
-			if (top == 49)
-			{
-				cout << "\nOverflow";
-			}
-			else
-			{
-				data[top] = x;
-				top++;
-			}
-		}
+        else
+        {
+            int pos = 0;
 
-		else
-		{
-			int pos = 0;
+            for (int i = 0; i < top - 1; i++)
+            {
+                if (data[i] <= x && x <= data[i + 1])
+                {
+                    pos = i + 1;
+                    break;
+                }
+            }
+            if (pos == 0)
+            {
+                pos = top - 1;
+            }
 
-			for (int i = 0; i < top - 1; i++)
-			{
-				if (data[i] <= x && x <= data[i + 1])
-				{
-					pos = i + 1;
-					break;
-				}
-			}
-			if (pos == 0)
-			{
-				pos = top - 1;
-			}
+            for (int i = top; i > pos; i--)
+            {
+                data[i] = data[i - 1];
+            }
+            top++;
+            data[pos] = x;
+        }
+    }
 
-			for (int i = top; i > pos; i--)
-			{
-				data[i] = data[i - 1];
-			}
-			top++;
-			data[pos] = x;
-		}
-	}
+    void Remove(int x)
+    {
+        int pos = Search(x);
+        cout << "\n" << data[pos] << " deleted";
+        for (int i = pos; i < top; i++)
+        {
+            data[i] = data[i + 1];
+        }
+        top--;
+    }
 
-	void Remove(int x)
-	{
-		int pos = Search(x);
-		cout << "\n"
-			 << data[pos] << " deleted";
-		for (int i = pos; i < top; i++)
-		{
-			data[i] = data[i + 1];
-		}
-		top--;
-	}
-
-	void Show()
-	{
-		for (int i = 0; i < top; i++)
-		{
-			cout << data[i] << "\t";
-		}
-	}
+    void Show()
+    {
+        for (int i = 0; i < top; i++)
+        {
+            cout << data[i] << "\t";
+        }
+    }
 };
 
 int main()
 {
-	list L;
-	int choice;
-	int x;
-	do
-	{
-		cout << "\n1.Insert";
-		cout << "\n2.Delete";
-		cout << "\n3.Search";
-		cout << "\n4.Sort";
-		cout << "\n5.Print";
-		cout << "\n\nEnter Your Choice : ";
-		cin >> choice;
-		switch (choice)
-		{
-		case 1:
-			cout << "\nEnter the element to be inserted : ";
-			cin >> x;
-			L.insert(x);
-			break;
-		case 2:
-			cout << "\nEnter the element to be removed : ";
-			cin >> x;
-			L.Remove(x);
-			break;
-		case 3:
-			cout << "\nEnter the element to be searched : ";
-			cin >> x;
-			L.Search(x);
-			break;
-		case 4:
-			L.Sort();
-			break;
-		case 5:
-			L.Show();
-			break;
-		}
-	} while (choice != 0);
-	return 0;
+    list L;
+    int choice;
+    int x;
+    do
+    {
+        cout << "\n1.Insert";
+        cout << "\n2.Delete";
+        cout << "\n3.Search";
+        cout << "\n4.Sort";
+        cout << "\n5.Print";
+        cout << "\n\nEnter Your Choice : ";
+        cin >> choice;
+        switch (choice)
+        {
+        case 1:
+            cout << "\nEnter the element to be inserted : ";
+            cin >> x;
+            L.insert(x);
+            break;
+        case 2:
+            cout << "\nEnter the element to be removed : ";
+            cin >> x;
+            L.Remove(x);
+            break;
+        case 3:
+            cout << "\nEnter the element to be searched : ";
+            cin >> x;
+            L.Search(x);
+            break;
+        case 4:
+            L.Sort();
+            break;
+        case 5:
+            L.Show();
+            break;
+        }
+    } while (choice != 0);
+    return 0;
 }
diff --git a/data_structure/morrisinorder.cpp b/data_structure/morrisinorder.cpp
index d3a2e9fd7..58f267907 100644
--- a/data_structure/morrisinorder.cpp
+++ b/data_structure/morrisinorder.cpp
@@ -2,107 +2,107 @@
 #include <queue>
 
 /**************************
-	@author shrutisheoran
+    @author shrutisheoran
 **************************/
 
 using namespace std;
 
 struct Btree
 {
-	int data;
-	struct Btree *left;  //Pointer to left subtree
-	struct Btree *right; //Pointer to right subtree
+    int data;
+    struct Btree *left;   // Pointer to left subtree
+    struct Btree *right;  // Pointer to right subtree
 };
 
 void insert(Btree **root, int d)
 {
-	Btree *nn = new Btree(); //Creating new node
-	nn->data = d;
-	nn->left = NULL;
-	nn->right = NULL;
-	if (*root == NULL)
-	{
-		*root = nn;
-		return;
-	}
-	else
-	{
-		queue<Btree *> q;
-		// Adding root node to queue
-		q.push(*root);
-		while (!q.empty())
-		{
-			Btree *node = q.front();
-			// Removing parent node from queue
-			q.pop();
-			if (node->left)
-				// Adding left child of removed node to queue
-				q.push(node->left);
-			else
-			{
-				// Adding new node if no left child is present
-				node->left = nn;
-				return;
-			}
-			if (node->right)
-				// Adding right child of removed node to queue
-				q.push(node->right);
-			else
-			{
-				// Adding new node if no right child is present
-				node->right = nn;
-				return;
-			}
-		}
-	}
+    Btree *nn = new Btree();  // Creating new node
+    nn->data = d;
+    nn->left = NULL;
+    nn->right = NULL;
+    if (*root == NULL)
+    {
+        *root = nn;
+        return;
+    }
+    else
+    {
+        queue<Btree *> q;
+        // Adding root node to queue
+        q.push(*root);
+        while (!q.empty())
+        {
+            Btree *node = q.front();
+            // Removing parent node from queue
+            q.pop();
+            if (node->left)
+                // Adding left child of removed node to queue
+                q.push(node->left);
+            else
+            {
+                // Adding new node if no left child is present
+                node->left = nn;
+                return;
+            }
+            if (node->right)
+                // Adding right child of removed node to queue
+                q.push(node->right);
+            else
+            {
+                // Adding new node if no right child is present
+                node->right = nn;
+                return;
+            }
+        }
+    }
 }
 
 void morrisInorder(Btree *root)
 {
-	Btree *curr = root;
-	Btree *temp;
-	while (curr)
-	{
-		if (curr->left == NULL)
-		{
-			cout << curr->data << " ";
-			// If left of current node is NULL then curr is shifted to right
-			curr = curr->right;
-		}
-		else
-		{
-			// Left of current node is stored in temp
-			temp = curr->left;
-			// Moving to extreme right of temp
-			while (temp->right && temp->right != curr)
-				temp = temp->right;
-			// If extreme right is null it is made to point to currrent node (will be used for backtracking)
-			if (temp->right == NULL)
-			{
-				temp->right = curr;
-				// current node is made to point its left subtree
-				curr = curr->left;
-			}
-			// If extreme right already points to currrent node it it set to null
-			else if (temp->right == curr)
-			{
-				cout << curr->data << " ";
-				temp->right = NULL;
-				// current node is made to point its right subtree
-				curr = curr->right;
-			}
-		}
-	}
+    Btree *curr = root;
+    Btree *temp;
+    while (curr)
+    {
+        if (curr->left == NULL)
+        {
+            cout << curr->data << " ";
+            // If left of current node is NULL then curr is shifted to right
+            curr = curr->right;
+        }
+        else
+        {
+            // Left of current node is stored in temp
+            temp = curr->left;
+            // Moving to extreme right of temp
+            while (temp->right && temp->right != curr) temp = temp->right;
+            // If extreme right is null it is made to point to currrent node
+            // (will be used for backtracking)
+            if (temp->right == NULL)
+            {
+                temp->right = curr;
+                // current node is made to point its left subtree
+                curr = curr->left;
+            }
+            // If extreme right already points to currrent node it it set to
+            // null
+            else if (temp->right == curr)
+            {
+                cout << curr->data << " ";
+                temp->right = NULL;
+                // current node is made to point its right subtree
+                curr = curr->right;
+            }
+        }
+    }
 }
 
 int main()
 {
-	// Testing morrisInorder funtion
-	Btree *root = NULL;
-	int i;
-	for (i = 1; i <= 7; i++)
-		insert(&root, i);
-	cout << "Morris Inorder: ";
-	morrisInorder(root);
-	return 0;
+    // Testing morrisInorder funtion
+    Btree *root = NULL;
+    int i;
+    for (i = 1; i <= 7; i++) insert(&root, i);
+    cout << "Morris Inorder: ";
+    morrisInorder(root);
+    return 0;
 }
diff --git a/data_structure/queue/queue.cpp b/data_structure/queue/queue.cpp
index 728adfc18..e8ff8966c 100644
--- a/data_structure/queue/queue.cpp
+++ b/data_structure/queue/queue.cpp
@@ -1,6 +1,6 @@
-#include <iostream>
-#include <assert.h>
 #include "queue.h"
+#include <assert.h>
+#include <iostream>
 
 using namespace std;
 
@@ -25,11 +25,12 @@ void queue<Kind>::display()
 {
     node<Kind> *current = queueFront;
     cout << "Front --> ";
-    while(current != NULL) {
-        cout<<current->data<< "    ";
-        current = current -> next;
+    while (current != NULL)
+    {
+        cout << current->data << "    ";
+        current = current->next;
     }
-    cout <<endl;
+    cout << endl;
     cout << "Size of queue: " << size << endl;
 }
 
@@ -55,10 +56,13 @@ void queue<Kind>::enQueue(Kind item)
     newNode = new node<Kind>;
     newNode->data = item;
     newNode->next = NULL;
-    if (queueFront == NULL) {
+    if (queueFront == NULL)
+    {
         queueFront = newNode;
         queueRear = newNode;
-    } else {
+    }
+    else
+    {
         queueRear->next = newNode;
         queueRear = queueRear->next;
     }
@@ -78,13 +82,15 @@ template <class Kind>
 void queue<Kind>::deQueue()
 {
     node<Kind> *temp;
-    if(!isEmptyQueue()) {
+    if (!isEmptyQueue())
+    {
         temp = queueFront;
         queueFront = queueFront->next;
         delete temp;
         size--;
-    } else {
+    }
+    else
+    {
         cout << "Queue is empty !" << endl;
     }
 }
-
diff --git a/data_structure/queue/queue.h b/data_structure/queue/queue.h
index 715def1ef..7e9c44559 100644
--- a/data_structure/queue/queue.h
+++ b/data_structure/queue/queue.h
@@ -14,21 +14,20 @@ struct node
 template <class Kind>
 class queue
 {
-    public:
-        void display();        /* Show queue */
-        queue();               /* Default constructor*/
-        ~queue();              /* Destructor */
-        bool isEmptyQueue();   /* Determine whether the queue is empty */
-        void enQueue (Kind item); /* Add new item to the queue */
-        Kind front();            /* Return the first element of the queue */
-        void deQueue();        /* Remove the top element of the queue */
-        void clear();
+ public:
+    void display();          /* Show queue */
+    queue();                 /* Default constructor*/
+    ~queue();                /* Destructor */
+    bool isEmptyQueue();     /* Determine whether the queue is empty */
+    void enQueue(Kind item); /* Add new item to the queue */
+    Kind front();            /* Return the first element of the queue */
+    void deQueue();          /* Remove the top element of the queue */
+    void clear();
 
-    private:
-        node<Kind> *queueFront;  /* Pointer to the front of the queue */
-        node<Kind> *queueRear;   /* Pointer to the rear of the queue  */
-        int size;
+ private:
+    node<Kind> *queueFront; /* Pointer to the front of the queue */
+    node<Kind> *queueRear;  /* Pointer to the rear of the queue  */
+    int size;
 };
 
 #endif
-
diff --git a/data_structure/queue/test_queue.cpp b/data_structure/queue/test_queue.cpp
index caf80318c..d9308adcb 100644
--- a/data_structure/queue/test_queue.cpp
+++ b/data_structure/queue/test_queue.cpp
@@ -1,22 +1,25 @@
 #include <iostream>
 #include <string>
-#include "queue.h"
 #include "queue.cpp"
+#include "queue.h"
 
 using namespace std;
 
 int main()
 {
     queue<string> q;
-    cout << "---------------------- Test construct ----------------------" << endl;
+    cout << "---------------------- Test construct ----------------------"
+         << endl;
     q.display();
-    cout << "---------------------- Test isEmptyQueue ----------------------" << endl;
-    if(q.isEmptyQueue())
-        cout << "PASS" <<endl;
+    cout << "---------------------- Test isEmptyQueue ----------------------"
+         << endl;
+    if (q.isEmptyQueue())
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
-    cout << "---------------------- Test enQueue ----------------------" << endl;
-    cout << "After Hai, Jeff, Tom, Jkingston go into queue: "<<endl;
+        cout << "FAIL" << endl;
+    cout << "---------------------- Test enQueue ----------------------"
+         << endl;
+    cout << "After Hai, Jeff, Tom, Jkingston go into queue: " << endl;
     q.enQueue("Hai");
     q.enQueue("Jeff");
     q.enQueue("Tom");
@@ -25,14 +28,15 @@ int main()
     cout << "---------------------- Test front ----------------------" << endl;
     string value = q.front();
     if (value == "Hai")
-        cout << "PASS" <<endl;
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
-    cout << "---------------------- Test deQueue ----------------------" << endl;
+        cout << "FAIL" << endl;
+    cout << "---------------------- Test deQueue ----------------------"
+         << endl;
     q.display();
     q.deQueue();
     q.deQueue();
-    cout << "After Hai, Jeff left the queue: "<< endl;
+    cout << "After Hai, Jeff left the queue: " << endl;
     q.display();
     return 0;
 }
diff --git a/data_structure/queue_using_array.cpp b/data_structure/queue_using_array.cpp
index ccd6e3cd6..c7fbf1ef7 100644
--- a/data_structure/queue_using_array.cpp
+++ b/data_structure/queue_using_array.cpp
@@ -10,13 +10,15 @@
 
 #define MAXSIZE 10
 
-class Queue_Array {
+class Queue_Array
+{
     int front;
     int rear;
     int size;
 
  public:
-    Queue_Array() {
+    Queue_Array()
+    {
         front = -1;
         rear = -1;
         size = MAXSIZE;
@@ -27,43 +29,59 @@ class Queue_Array {
     void display();
 };
 
-void Queue_Array::enqueue(int ele) {
-    if (rear == size - 1) {
+void Queue_Array::enqueue(int ele)
+{
+    if (rear == size - 1)
+    {
         std::cout << "\nStack is full";
-    } else if (front == -1 && rear == -1) {
+    }
+    else if (front == -1 && rear == -1)
+    {
         front = rear = 0;
         arr[rear] = ele;
-    } else if (rear < size) {
+    }
+    else if (rear < size)
+    {
         rear++;
         arr[rear] = ele;
     }
 }
 
-int Queue_Array::dequeue() {
+int Queue_Array::dequeue()
+{
     int d;
-    if (front == -1) {
+    if (front == -1)
+    {
         std::cout << "\nstack is empty ";
         return 0;
-    } else if (front == rear) {
+    }
+    else if (front == rear)
+    {
         d = arr[front];
         front = rear = -1;
-    } else {
+    }
+    else
+    {
         d = arr[front++];
     }
 
     return d;
 }
 
-void Queue_Array::display() {
-    if (front == -1) {
+void Queue_Array::display()
+{
+    if (front == -1)
+    {
         std::cout << "\nStack is empty";
-    } else {
-        for (int i = front; i <= rear; i++)
-            std::cout << arr[i] << " ";
+    }
+    else
+    {
+        for (int i = front; i <= rear; i++) std::cout << arr[i] << " ";
     }
 }
 
-int main() {
+int main()
+{
     int op, data;
 
     Queue_Array ob;
@@ -72,21 +90,31 @@ int main() {
     std::cout << "\n2. dequeue(Deletion)";
     std::cout << "\n3. Display";
     std::cout << "\n4. Exit";
-    while (1) {
+    while (1)
+    {
         std::cout << "\nEnter your choice ";
         std::cin >> op;
-        if (op == 1) {
+        if (op == 1)
+        {
             std::cout << "Enter data  ";
             std::cin >> data;
             ob.enqueue(data);
-        } else if (op == 2) {
+        }
+        else if (op == 2)
+        {
             data = ob.dequeue();
             std::cout << "\ndequeue element is:\t" << data;
-        } else if (op == 3) {
+        }
+        else if (op == 3)
+        {
             ob.display();
-        } else if (op == 4) {
+        }
+        else if (op == 4)
+        {
             exit(0);
-        } else {
+        }
+        else
+        {
             std::cout << "\nWrong choice ";
         }
     }
diff --git a/data_structure/queue_using_array2.cpp b/data_structure/queue_using_array2.cpp
index 3b79d06fc..7e1ada725 100644
--- a/data_structure/queue_using_array2.cpp
+++ b/data_structure/queue_using_array2.cpp
@@ -7,69 +7,68 @@ int rear = 0;
 
 void Enque(int x)
 {
-	if (rear == 10)
-	{
-		cout << "\nOverflow";
-	}
-	else
-	{
-		queue[rear++] = x;
-	}
+    if (rear == 10)
+    {
+        cout << "\nOverflow";
+    }
+    else
+    {
+        queue[rear++] = x;
+    }
 }
 
 void Deque()
 {
-	if (front == rear)
-	{
-		cout << "\nUnderflow";
-	}
+    if (front == rear)
+    {
+        cout << "\nUnderflow";
+    }
 
-	else
-	{
-		cout << "\n"
-			 << queue[front++] << " deleted";
-		for (int i = front; i < rear; i++)
-		{
-			queue[i - front] = queue[i];
-		}
-		rear = rear - front;
-		front = 0;
-	}
+    else
+    {
+        cout << "\n" << queue[front++] << " deleted";
+        for (int i = front; i < rear; i++)
+        {
+            queue[i - front] = queue[i];
+        }
+        rear = rear - front;
+        front = 0;
+    }
 }
 
 void show()
 {
-	for (int i = front; i < rear; i++)
-	{
-		cout << queue[i] << "\t";
-	}
+    for (int i = front; i < rear; i++)
+    {
+        cout << queue[i] << "\t";
+    }
 }
 
 int main()
 {
-	int ch, x;
-	do
-	{
-		cout << "\n1. Enque";
-		cout << "\n2. Deque";
-		cout << "\n3. Print";
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		if (ch == 1)
-		{
-			cout << "\nInsert : ";
-			cin >> x;
-			Enque(x);
-		}
-		else if (ch == 2)
-		{
-			Deque();
-		}
-		else if (ch == 3)
-		{
-			show();
-		}
-	} while (ch != 0);
+    int ch, x;
+    do
+    {
+        cout << "\n1. Enque";
+        cout << "\n2. Deque";
+        cout << "\n3. Print";
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cout << "\nInsert : ";
+            cin >> x;
+            Enque(x);
+        }
+        else if (ch == 2)
+        {
+            Deque();
+        }
+        else if (ch == 3)
+        {
+            show();
+        }
+    } while (ch != 0);
 
-	return 0;
+    return 0;
 }
diff --git a/data_structure/queue_using_linked_list.cpp b/data_structure/queue_using_linked_list.cpp
index 39d7a9ae3..9ddbdaa42 100644
--- a/data_structure/queue_using_linked_list.cpp
+++ b/data_structure/queue_using_linked_list.cpp
@@ -22,7 +22,6 @@ void Enque(int x)
 
     else
     {
-
         node *n = new node;
         n->val = x;
         n->next = NULL;
@@ -40,8 +39,7 @@ void Deque()
     else
     {
         node *t = front;
-        cout << "\n"
-             << t->val << " deleted";
+        cout << "\n" << t->val << " deleted";
         front = front->next;
         delete t;
         if (front == NULL)
diff --git a/data_structure/queue_using_linkedlist.cpp b/data_structure/queue_using_linkedlist.cpp
index 8bc130c27..21ff0cfcf 100644
--- a/data_structure/queue_using_linkedlist.cpp
+++ b/data_structure/queue_using_linkedlist.cpp
@@ -1,98 +1,99 @@
 /*
     Write a program to implement Queue using linkedlist.
 */
-#include<iostream>
-
-
-struct linkedlist{
-  int data;
-  linkedlist *next;
+#include <iostream>
 
+struct linkedlist
+{
+    int data;
+    linkedlist *next;
 };
-class stack_linkedList{
-  public:
+class stack_linkedList
+{
+ public:
     linkedlist *front;
     linkedlist *rear;
-    
-    stack_linkedList(){
-        front=rear=NULL;
-    }
+
+    stack_linkedList() { front = rear = NULL; }
     void enqueue(int);
     int dequeue();
     void display();
-
 };
-void stack_linkedList::enqueue(int ele){
-    
-    linkedlist *temp=new linkedlist();
-    temp->data=ele;
-    temp->next=NULL;
+void stack_linkedList::enqueue(int ele)
+{
+    linkedlist *temp = new linkedlist();
+    temp->data = ele;
+    temp->next = NULL;
 
-    if(front==NULL)
-        front=rear=temp;
-    else{
-        rear->next=temp;
-        rear=temp;
+    if (front == NULL)
+        front = rear = temp;
+    else
+    {
+        rear->next = temp;
+        rear = temp;
     }
 }
-int stack_linkedList::dequeue(){
+int stack_linkedList::dequeue()
+{
     linkedlist *temp;
     int ele;
-    if(front==NULL)
-        std::cout<<"\nStack is empty";
-    else{
-        temp=front;
-        ele=temp->data;
-        if(front==rear)                                         //if length of queue is 1;
-            rear=rear->next;
-        front=front->next;
-        delete(temp);
+    if (front == NULL)
+        std::cout << "\nStack is empty";
+    else
+    {
+        temp = front;
+        ele = temp->data;
+        if (front == rear)  // if length of queue is 1;
+            rear = rear->next;
+        front = front->next;
+        delete (temp);
     }
     return ele;
 }
-void stack_linkedList::display(){
-    
-    if(front==NULL)
-        std::cout<<"\nStack is empty";
-    
-    else {
-        
+void stack_linkedList::display()
+{
+    if (front == NULL)
+        std::cout << "\nStack is empty";
+
+    else
+    {
         linkedlist *temp;
-        temp=front;
-        while(temp!=NULL){
-            std::cout<<temp->data<<" ";
-            temp=temp->next;
+        temp = front;
+        while (temp != NULL)
+        {
+            std::cout << temp->data << " ";
+            temp = temp->next;
         }
     }
 }
 
-int main(){
-    
-    int op,data;
+int main()
+{
+    int op, data;
     stack_linkedList ob;
-    std::cout<<"\n1. enqueue(Insertion) ";
-    std::cout<<"\n2. dequeue(Deletion)";
-    std::cout<<"\n3. Display";
-    std::cout<<"\n4. Exit";
-    
-    while(1){
-        std::cout<<"\nEnter your choice ";
-        std::cin>>op;
-        if(op==1)
+    std::cout << "\n1. enqueue(Insertion) ";
+    std::cout << "\n2. dequeue(Deletion)";
+    std::cout << "\n3. Display";
+    std::cout << "\n4. Exit";
+
+    while (1)
+    {
+        std::cout << "\nEnter your choice ";
+        std::cin >> op;
+        if (op == 1)
         {
-            std::cout<<"Enter data ";
-            std::cin>>data;
+            std::cout << "Enter data ";
+            std::cin >> data;
             ob.enqueue(data);
         }
-        else if(op==2)
-            data=ob.dequeue();
-        else if(op==3)
+        else if (op == 2)
+            data = ob.dequeue();
+        else if (op == 3)
             ob.display();
-        else if(op==4)
+        else if (op == 4)
             exit(0);
         else
-            std::cout<<"\nWrong choice ";
-
+            std::cout << "\nWrong choice ";
     }
     return 0;
 }
diff --git a/data_structure/stack_using_array.cpp b/data_structure/stack_using_array.cpp
index af1d57c46..dd0709ff2 100644
--- a/data_structure/stack_using_array.cpp
+++ b/data_structure/stack_using_array.cpp
@@ -6,74 +6,70 @@ int top = 0, size;
 
 void push(int x)
 {
-	if (top == size)
-	{
-		cout << "\nOverflow";
-	}
-	else
-	{
-		stack[top++] = x;
-	}
+    if (top == size)
+    {
+        cout << "\nOverflow";
+    }
+    else
+    {
+        stack[top++] = x;
+    }
 }
 
 void pop()
 {
-	if (top == 0)
-	{
-		cout << "\nUnderflow";
-	}
-	else
-	{
-		cout << "\n"
-			 << stack[--top] << " deleted";
-	}
+    if (top == 0)
+    {
+        cout << "\nUnderflow";
+    }
+    else
+    {
+        cout << "\n" << stack[--top] << " deleted";
+    }
 }
 
 void show()
 {
-	for (int i = 0; i < top; i++)
-	{
-		cout << stack[i] << "\n";
-	}
+    for (int i = 0; i < top; i++)
+    {
+        cout << stack[i] << "\n";
+    }
 }
 
-void topmost()
-{
-	cout << "\nTopmost element: " << stack[top - 1];
-}
+void topmost() { cout << "\nTopmost element: " << stack[top - 1]; }
 int main()
 {
-	cout << "\nEnter Size of stack : ";
-	cin >> size;
-	stack = new int[size];
-	int ch, x;
-	do
-	{
-		cout << "\n1. Push";
-		cout << "\n2. Pop";
-		cout << "\n3. Print";
-		cout << "\n4. Print topmost element:";
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		if (ch == 1)
-		{
-			cout << "\nInsert : ";
-			cin >> x;
-			push(x);
-		}
-		else if (ch == 2)
-		{
-			pop();
-		}
-		else if (ch == 3)
-		{
-			show();
-		}
-		else if (ch == 4)
-		{
-			topmost();
-		}
-	} while (ch != 0);
+    cout << "\nEnter Size of stack : ";
+    cin >> size;
+    stack = new int[size];
+    int ch, x;
+    do
+    {
+        cout << "\n1. Push";
+        cout << "\n2. Pop";
+        cout << "\n3. Print";
+        cout << "\n4. Print topmost element:";
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cout << "\nInsert : ";
+            cin >> x;
+            push(x);
+        }
+        else if (ch == 2)
+        {
+            pop();
+        }
+        else if (ch == 3)
+        {
+            show();
+        }
+        else if (ch == 4)
+        {
+            topmost();
+        }
+    } while (ch != 0);
 
-	return 0;
+    return 0;
 }
diff --git a/data_structure/stack_using_linked_list.cpp b/data_structure/stack_using_linked_list.cpp
index 6925cf10c..89a15fe39 100644
--- a/data_structure/stack_using_linked_list.cpp
+++ b/data_structure/stack_using_linked_list.cpp
@@ -3,71 +3,70 @@ using namespace std;
 
 struct node
 {
-	int val;
-	node *next;
+    int val;
+    node *next;
 };
 
 node *top;
 
 void push(int x)
 {
-	node *n = new node;
-	n->val = x;
-	n->next = top;
-	top = n;
+    node *n = new node;
+    n->val = x;
+    n->next = top;
+    top = n;
 }
 
 void pop()
 {
-	if (top == NULL)
-	{
-		cout << "\nUnderflow";
-	}
-	else
-	{
-		node *t = top;
-		cout << "\n"
-			 << t->val << " deleted";
-		top = top->next;
-		delete t;
-	}
+    if (top == NULL)
+    {
+        cout << "\nUnderflow";
+    }
+    else
+    {
+        node *t = top;
+        cout << "\n" << t->val << " deleted";
+        top = top->next;
+        delete t;
+    }
 }
 
 void show()
 {
-	node *t = top;
-	while (t != NULL)
-	{
-		cout << t->val << "\n";
-		t = t->next;
-	}
+    node *t = top;
+    while (t != NULL)
+    {
+        cout << t->val << "\n";
+        t = t->next;
+    }
 }
 
 int main()
 {
-	int ch, x;
-	do
-	{
-		cout << "\n1. Push";
-		cout << "\n2. Pop";
-		cout << "\n3. Print";
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		if (ch == 1)
-		{
-			cout << "\nInsert : ";
-			cin >> x;
-			push(x);
-		}
-		else if (ch == 2)
-		{
-			pop();
-		}
-		else if (ch == 3)
-		{
-			show();
-		}
-	} while (ch != 0);
+    int ch, x;
+    do
+    {
+        cout << "\n1. Push";
+        cout << "\n2. Pop";
+        cout << "\n3. Print";
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cout << "\nInsert : ";
+            cin >> x;
+            push(x);
+        }
+        else if (ch == 2)
+        {
+            pop();
+        }
+        else if (ch == 3)
+        {
+            show();
+        }
+    } while (ch != 0);
 
-	return 0;
+    return 0;
 }
diff --git a/data_structure/stk/main.cpp b/data_structure/stk/main.cpp
index 2d6bbec56..ceac2ac8a 100644
--- a/data_structure/stk/main.cpp
+++ b/data_structure/stk/main.cpp
@@ -8,18 +8,19 @@
  *     ./main student.txt
  ************************************************************
  * */
-#include <iostream>
-#include <iomanip>
-#include <fstream>
-#include <string>
 #include <assert.h>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <string>
 
-#include "stack.h"
 #include "stack.cpp"
+#include "stack.h"
 
 using namespace std;
 
-int main(int argc, char * argv[]) {
+int main(int argc, char* argv[])
+{
     double GPA;
     double highestGPA;
     string name;
@@ -34,19 +35,24 @@ int main(int argc, char * argv[]) {
     infile >> GPA >> name;
     highestGPA = GPA;
 
-    while (infile) {
-        if (GPA > highestGPA) {
+    while (infile)
+    {
+        if (GPA > highestGPA)
+        {
             stk.clear();
             stk.push(name);
             highestGPA = GPA;
-        } else if (GPA == highestGPA) {
+        }
+        else if (GPA == highestGPA)
+        {
             stk.push(name);
         }
         infile >> GPA >> name;
     }
-    cout << "Highest GPA: " << highestGPA <<endl;
+    cout << "Highest GPA: " << highestGPA << endl;
     cout << "Students the highest GPA are: " << endl;
-    while (!stk.isEmptyStack()) {
+    while (!stk.isEmptyStack())
+    {
         cout << stk.top() << endl;
         stk.pop();
     }
diff --git a/data_structure/stk/stack.cpp b/data_structure/stk/stack.cpp
index 1e87d7c14..9f92efbd5 100644
--- a/data_structure/stk/stack.cpp
+++ b/data_structure/stk/stack.cpp
@@ -1,6 +1,6 @@
-#include <iostream>
-#include <assert.h>
 #include "stack.h"
+#include <assert.h>
+#include <iostream>
 
 using namespace std;
 
@@ -24,11 +24,12 @@ void stack<Type>::display()
 {
     node<Type> *current = stackTop;
     cout << "Top --> ";
-    while(current != NULL) {
-        cout<<current->data<< "  ";
-        current = current -> next;
+    while (current != NULL)
+    {
+        cout << current->data << "  ";
+        current = current->next;
     }
-    cout <<endl;
+    cout << endl;
     cout << "Size of stack: " << size << endl;
 }
 
@@ -71,19 +72,22 @@ template <class Type>
 void stack<Type>::pop()
 {
     node<Type> *temp;
-    if(!isEmptyStack()) {
+    if (!isEmptyStack())
+    {
         temp = stackTop;
         stackTop = stackTop->next;
         delete temp;
         size--;
-    } else {
+    }
+    else
+    {
         cout << "Stack is empty !" << endl;
     }
 }
 
 /* Operator "=" */
 template <class Type>
-stack<Type> stack<Type>::operator=(stack<Type> & otherStack)
+stack<Type> stack<Type>::operator=(stack<Type> &otherStack)
 {
     node<Type> *newNode, *current, *last;
 
@@ -91,13 +95,14 @@ stack<Type> stack<Type>::operator=(stack<Type> & otherStack)
         stackTop = NULL;
     if (otherStack.stackTop == NULL)
         stackTop = NULL;
-    else {
+    else
+    {
         current = otherStack.stackTop;
         stackTop = new node<Type>;
         stackTop->data = current->data;
         stackTop->next = NULL;
         last = stackTop;
-        current = current ->next;
+        current = current->next;
         /* Copy the remaining stack */
         while (current != NULL)
         {
diff --git a/data_structure/stk/stack.h b/data_structure/stk/stack.h
index a93669482..39b455ac0 100644
--- a/data_structure/stk/stack.h
+++ b/data_structure/stk/stack.h
@@ -14,22 +14,21 @@ struct node
 template <class Type>
 class stack
 {
-    public:
-        void display();        /* Show stack */
-        stack();               /* Default constructor*/
-        ~stack();              /* Destructor */
-        bool isEmptyStack();   /* Determine whether the stack is empty */
-        void push (Type item); /* Add new item to the stack */
-        Type top();            /* Return the top element of the stack */
-        void pop();            /* Remove the top element of the stack */
-        void clear();
+ public:
+    void display();       /* Show stack */
+    stack();              /* Default constructor*/
+    ~stack();             /* Destructor */
+    bool isEmptyStack();  /* Determine whether the stack is empty */
+    void push(Type item); /* Add new item to the stack */
+    Type top();           /* Return the top element of the stack */
+    void pop();           /* Remove the top element of the stack */
+    void clear();
 
-        stack<Type> operator=(stack<Type> & otherStack);
-        // Overload "=" the assignment operator.
-    private:
-        node<Type> *stackTop;  /* Pointer to the stack */
-        int size;
+    stack<Type> operator=(stack<Type> &otherStack);
+    // Overload "=" the assignment operator.
+ private:
+    node<Type> *stackTop; /* Pointer to the stack */
+    int size;
 };
 
 #endif
-
diff --git a/data_structure/stk/test_stack.cpp b/data_structure/stk/test_stack.cpp
index 4703fc906..8839fdfa3 100644
--- a/data_structure/stk/test_stack.cpp
+++ b/data_structure/stk/test_stack.cpp
@@ -1,21 +1,23 @@
 #include <iostream>
-#include "stack.h"
 #include "stack.cpp"
+#include "stack.h"
 
 using namespace std;
 
 int main()
 {
     stack<int> stk;
-    cout << "---------------------- Test construct ----------------------" << endl;
+    cout << "---------------------- Test construct ----------------------"
+         << endl;
     stk.display();
-    cout << "---------------------- Test isEmptyStack ----------------------" << endl;
-    if(stk.isEmptyStack())
-        cout << "PASS" <<endl;
+    cout << "---------------------- Test isEmptyStack ----------------------"
+         << endl;
+    if (stk.isEmptyStack())
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
+        cout << "FAIL" << endl;
     cout << "---------------------- Test push ----------------------" << endl;
-    cout << "After pushing 10 20 30 40 into stack: "<<endl;
+    cout << "After pushing 10 20 30 40 into stack: " << endl;
     stk.push(10);
     stk.push(20);
     stk.push(30);
@@ -24,28 +26,30 @@ int main()
     cout << "---------------------- Test top ----------------------" << endl;
     int value = stk.top();
     if (value == 40)
-        cout << "PASS" <<endl;
+        cout << "PASS" << endl;
     else
-        cout << "FAIL" <<endl;
+        cout << "FAIL" << endl;
     cout << "---------------------- Test pop ----------------------" << endl;
     stk.display();
     stk.pop();
     stk.pop();
-    cout << "After popping 2 times: "<< endl;
+    cout << "After popping 2 times: " << endl;
     stk.display();
-    cout << "---------------------- Test overload = operator ----------------------" << endl;
+    cout << "---------------------- Test overload = operator "
+            "----------------------"
+         << endl;
     stack<int> stk1;
-    cout << "stk current: "<< endl;
+    cout << "stk current: " << endl;
     stk.display();
-    cout << endl << "Assign stk1 = stk "<< endl;
+    cout << endl << "Assign stk1 = stk " << endl;
     stk1 = stk;
     stk1.display();
-    cout << endl<< "After pushing 8 9 10 into stk1:" <<endl;
+    cout << endl << "After pushing 8 9 10 into stk1:" << endl;
     stk1.push(8);
     stk1.push(9);
     stk1.push(10);
     stk1.display();
-    cout << endl << "stk current: " <<endl;
+    cout << endl << "stk current: " << endl;
     stk.display();
     cout << "Assign back stk = stk1:" << endl;
     stk = stk1;
diff --git a/data_structure/tree.cpp b/data_structure/tree.cpp
index 9ccc7069b..92d139b72 100644
--- a/data_structure/tree.cpp
+++ b/data_structure/tree.cpp
@@ -14,12 +14,12 @@ void CreateTree(node *curr, node *n, int x, char pos)
     if (n != NULL)
     {
         char ch;
-    cout << "\nLeft or Right of " << n->val << " : ";
-    cin >> ch;
-    if (ch == 'l')
-        CreateTree(n, n->left, x, ch);
-    else if (ch == 'r')
-        CreateTree(n, n->right, x, ch);
+        cout << "\nLeft or Right of " << n->val << " : ";
+        cin >> ch;
+        if (ch == 'l')
+            CreateTree(n, n->left, x, ch);
+        else if (ch == 'r')
+            CreateTree(n, n->right, x, ch);
     }
     else
     {
@@ -40,19 +40,19 @@ void CreateTree(node *curr, node *n, int x, char pos)
 
 void BFT(node *n)
 {
-    list<node*> queue;
+    list<node *> queue;
 
     queue.push_back(n);
 
-    while(!queue.empty())
+    while (!queue.empty())
     {
         n = queue.front();
         cout << n->val << "  ";
         queue.pop_front();
 
-        if(n->left != NULL)
+        if (n->left != NULL)
             queue.push_back(n->left);
-        if(n->right != NULL)
+        if (n->right != NULL)
             queue.push_back(n->right);
     }
 }
diff --git a/data_structure/trie_tree.cpp b/data_structure/trie_tree.cpp
index 2b84099e8..d34dd2dbc 100644
--- a/data_structure/trie_tree.cpp
+++ b/data_structure/trie_tree.cpp
@@ -1,86 +1,99 @@
-#include <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 #include <iostream>
 #include <string>
 
 // structure definition
-typedef struct trie {
-    struct trie * arr[26];
+typedef struct trie
+{
+    struct trie* arr[26];
     bool isEndofWord;
 } trie;
 
 // create a new node for trie
-trie * createNode() {
-    trie * nn = new trie();
-    for (int i = 0; i < 26; i++)
-        nn -> arr[i] = NULL;
-    nn -> isEndofWord = false;
+trie* createNode()
+{
+    trie* nn = new trie();
+    for (int i = 0; i < 26; i++) nn->arr[i] = NULL;
+    nn->isEndofWord = false;
     return nn;
 }
 
 // insert string into the trie
-void insert(trie * root, std::string str) {
-    for (int i = 0; i < str.length(); i++) {
+void insert(trie* root, std::string str)
+{
+    for (int i = 0; i < str.length(); i++)
+    {
         int j = str[i] - 'a';
-        if (root -> arr[j]) {
-            root = root -> arr[j];
-        } else {
-            root -> arr[j] = createNode();
-            root = root -> arr[j];
+        if (root->arr[j])
+        {
+            root = root->arr[j];
+        }
+        else
+        {
+            root->arr[j] = createNode();
+            root = root->arr[j];
         }
     }
-    root -> isEndofWord = true;
+    root->isEndofWord = true;
 }
 
 // search a string exists inside the trie
-bool search(trie * root, std::string str, int index) {
-    if (index == str.length()) {
-        if (!root -> isEndofWord)
+bool search(trie* root, std::string str, int index)
+{
+    if (index == str.length())
+    {
+        if (!root->isEndofWord)
             return false;
         return true;
     }
     int j = str[index] - 'a';
-    if (!root -> arr[j])
+    if (!root->arr[j])
         return false;
-    return search(root -> arr[j], str, index + 1);
+    return search(root->arr[j], str, index + 1);
 }
 
 /*
-removes the string if it is not a prefix of any  other 
-string, if it is then just sets the endofword to false, else 
+removes the string if it is not a prefix of any  other
+string, if it is then just sets the endofword to false, else
 removes the given string
 */
-bool deleteString(trie * root, std::string str, int index) {
-    if (index == str.length()) {
-        if (!root -> isEndofWord)
-            return false;
-        root -> isEndofWord = false;
-        for (int i = 0; i < 26; i++)
+bool deleteString(trie* root, std::string str, int index)
+{
+    if (index == str.length())
+    {
+        if (!root->isEndofWord)
             return false;
+        root->isEndofWord = false;
+        for (int i = 0; i < 26; i++) return false;
         return true;
     }
     int j = str[index] - 'a';
-    if (!root -> arr[j])
+    if (!root->arr[j])
         return false;
-    bool
-    var = deleteString(root, str, index + 1);
-    if (var) {
-        root -> arr[j] = NULL;
-        if (root -> isEndofWord) {
+    bool var = deleteString(root, str, index + 1);
+    if (var)
+    {
+        root->arr[j] = NULL;
+        if (root->isEndofWord)
+        {
             return false;
-        } else {
+        }
+        else
+        {
             int i;
             for (i = 0; i < 26; i++)
-                if (root -> arr[i])
+                if (root->arr[i])
                     return false;
             return true;
         }
     }
 }
 
-int main() {
-    trie * root = createNode();
+int main()
+{
+    trie* root = createNode();
     insert(root, "hello");
     insert(root, "world");
     int a = search(root, "hello", 0);
diff --git a/dynamic_programming/0_1_knapsack.cpp b/dynamic_programming/0_1_knapsack.cpp
index 9348372b2..0ce40ca0a 100644
--- a/dynamic_programming/0_1_knapsack.cpp
+++ b/dynamic_programming/0_1_knapsack.cpp
@@ -1,9 +1,9 @@
-//0-1 Knapsack problem - Dynamic programming
+// 0-1 Knapsack problem - Dynamic programming
 //#include <bits/stdc++.h>
 #include <iostream>
 using namespace std;
 
-//void Print(int res[20][20], int i, int j, int capacity)
+// void Print(int res[20][20], int i, int j, int capacity)
 //{
 //	if(i==0 || j==0)
 //	{
@@ -30,42 +30,43 @@ using namespace std;
 
 int Knapsack(int capacity, int n, int weight[], int value[])
 {
-	int res[20][20];
-	for (int i = 0; i < n + 1; ++i)
-	{
-		for (int j = 0; j < capacity + 1; ++j)
-		{
-			if (i == 0 || j == 0)
-				res[i][j] = 0;
-			else if (weight[i - 1] <= j)
-				res[i][j] = max(value[i - 1] + res[i - 1][j - weight[i - 1]], res[i - 1][j]);
-			else
-				res[i][j] = res[i - 1][j];
-		}
-	}
-	//	Print(res, n, capacity, capacity);
-	//	cout<<"\n";
-	return res[n][capacity];
+    int res[20][20];
+    for (int i = 0; i < n + 1; ++i)
+    {
+        for (int j = 0; j < capacity + 1; ++j)
+        {
+            if (i == 0 || j == 0)
+                res[i][j] = 0;
+            else if (weight[i - 1] <= j)
+                res[i][j] = max(value[i - 1] + res[i - 1][j - weight[i - 1]],
+                                res[i - 1][j]);
+            else
+                res[i][j] = res[i - 1][j];
+        }
+    }
+    //	Print(res, n, capacity, capacity);
+    //	cout<<"\n";
+    return res[n][capacity];
 }
 int main()
 {
-	int n;
-	cout << "Enter number of items: ";
-	cin >> n;
-	int weight[n], value[n];
-	cout << "Enter weights: ";
-	for (int i = 0; i < n; ++i)
-	{
-		cin >> weight[i];
-	}
-	cout << "Enter values: ";
-	for (int i = 0; i < n; ++i)
-	{
-		cin >> value[i];
-	}
-	int capacity;
-	cout << "Enter capacity: ";
-	cin >> capacity;
-	cout << Knapsack(capacity, n, weight, value);
-	return 0;
+    int n;
+    cout << "Enter number of items: ";
+    cin >> n;
+    int weight[n], value[n];
+    cout << "Enter weights: ";
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> weight[i];
+    }
+    cout << "Enter values: ";
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> value[i];
+    }
+    int capacity;
+    cout << "Enter capacity: ";
+    cin >> capacity;
+    cout << Knapsack(capacity, n, weight, value);
+    return 0;
 }
diff --git a/dynamic_programming/armstrong_number.cpp b/dynamic_programming/armstrong_number.cpp
index 4dba89a27..218d6365d 100644
--- a/dynamic_programming/armstrong_number.cpp
+++ b/dynamic_programming/armstrong_number.cpp
@@ -1,21 +1,23 @@
 // Program to check whether a number is an armstrong number or not
 #include <iostream>
 
-using std::cout;
 using std::cin;
+using std::cout;
 
-int main() {
-  int n, k, d, s = 0;
-  cout << "Enter a number:";
-  cin >> n;
-  k = n;
-  while (k != 0) {
-    d = k % 10;
-    s += d * d * d;
-    k /= 10;
-  }
-  if (s == n)
-    cout << n << "is an armstrong number";
-  else
-    cout << n << "is not an armstrong number";
+int main()
+{
+    int n, k, d, s = 0;
+    cout << "Enter a number:";
+    cin >> n;
+    k = n;
+    while (k != 0)
+    {
+        d = k % 10;
+        s += d * d * d;
+        k /= 10;
+    }
+    if (s == n)
+        cout << n << "is an armstrong number";
+    else
+        cout << n << "is not an armstrong number";
 }
diff --git a/dynamic_programming/bellman_ford.cpp b/dynamic_programming/bellman_ford.cpp
index 7c36d96df..85d3bff06 100644
--- a/dynamic_programming/bellman_ford.cpp
+++ b/dynamic_programming/bellman_ford.cpp
@@ -1,128 +1,129 @@
-#include <iostream>
 #include <limits.h>
+#include <iostream>
 
 using namespace std;
 
-//Wrapper class for storing an edge
+// Wrapper class for storing an edge
 class Edge
 {
-public:
-	int src, dst, weight;
+ public:
+    int src, dst, weight;
 };
 
-//Wrapper class for storing a graph
+// Wrapper class for storing a graph
 class Graph
 {
-public:
-	int vertexNum, edgeNum;
-	Edge *edges;
+ public:
+    int vertexNum, edgeNum;
+    Edge *edges;
 
-	//Constructs a graph with V vertices and E edges
-	Graph(int V, int E)
-	{
-		this->vertexNum = V;
-		this->edgeNum = E;
-		this->edges = (Edge *)malloc(E * sizeof(Edge));
-	}
+    // Constructs a graph with V vertices and E edges
+    Graph(int V, int E)
+    {
+        this->vertexNum = V;
+        this->edgeNum = E;
+        this->edges = (Edge *)malloc(E * sizeof(Edge));
+    }
 
-	//Adds the given edge to the graph
-	void addEdge(int src, int dst, int weight)
-	{
-		static int edgeInd = 0;
-		if (edgeInd < this->edgeNum)
-		{
-			Edge newEdge;
-			newEdge.src = src;
-			newEdge.dst = dst;
-			newEdge.weight = weight;
-			this->edges[edgeInd++] = newEdge;
-		}
-	}
+    // Adds the given edge to the graph
+    void addEdge(int src, int dst, int weight)
+    {
+        static int edgeInd = 0;
+        if (edgeInd < this->edgeNum)
+        {
+            Edge newEdge;
+            newEdge.src = src;
+            newEdge.dst = dst;
+            newEdge.weight = weight;
+            this->edges[edgeInd++] = newEdge;
+        }
+    }
 };
 
-//Utility function to print distances
+// Utility function to print distances
 void print(int dist[], int V)
 {
-	cout << "\nVertex  Distance" << endl;
-	for (int i = 0; i < V; i++)
-	{
-		if (dist[i] != INT_MAX)
-			cout << i << "\t" << dist[i] << endl;
-		else
-			cout << i << "\tINF" << endl;
-	}
+    cout << "\nVertex  Distance" << endl;
+    for (int i = 0; i < V; i++)
+    {
+        if (dist[i] != INT_MAX)
+            cout << i << "\t" << dist[i] << endl;
+        else
+            cout << i << "\tINF" << endl;
+    }
 }
 
-//The main function that finds the shortest path from given source
-//to all other vertices using Bellman-Ford.It also detects negative
-//weight cycle
+// The main function that finds the shortest path from given source
+// to all other vertices using Bellman-Ford.It also detects negative
+// weight cycle
 void BellmanFord(Graph graph, int src)
 {
-	int V = graph.vertexNum;
-	int E = graph.edgeNum;
-	int dist[V];
+    int V = graph.vertexNum;
+    int E = graph.edgeNum;
+    int dist[V];
 
-	//Initialize distances array as INF for all except source
-	//Intialize source as zero
-	for (int i = 0; i < V; i++)
-		dist[i] = INT_MAX;
-	dist[src] = 0;
+    // Initialize distances array as INF for all except source
+    // Intialize source as zero
+    for (int i = 0; i < V; i++) dist[i] = INT_MAX;
+    dist[src] = 0;
 
-	//Calculate shortest path distance from source to all edges
-	//A path can contain maximum (|V|-1) edges
-	for (int i = 0; i <= V - 1; i++)
-		for (int j = 0; j < E; j++)
-		{
-			int u = graph.edges[j].src;
-			int v = graph.edges[j].dst;
-			int w = graph.edges[j].weight;
+    // Calculate shortest path distance from source to all edges
+    // A path can contain maximum (|V|-1) edges
+    for (int i = 0; i <= V - 1; i++)
+        for (int j = 0; j < E; j++)
+        {
+            int u = graph.edges[j].src;
+            int v = graph.edges[j].dst;
+            int w = graph.edges[j].weight;
 
-			if (dist[u] != INT_MAX && dist[u] + w < dist[v])
-				dist[v] = dist[u] + w;
-		}
+            if (dist[u] != INT_MAX && dist[u] + w < dist[v])
+                dist[v] = dist[u] + w;
+        }
 
-	//Iterate inner loop once more to check for negative cycle
-	for (int j = 0; j < E; j++)
-	{
-		int u = graph.edges[j].src;
-		int v = graph.edges[j].dst;
-		int w = graph.edges[j].weight;
+    // Iterate inner loop once more to check for negative cycle
+    for (int j = 0; j < E; j++)
+    {
+        int u = graph.edges[j].src;
+        int v = graph.edges[j].dst;
+        int w = graph.edges[j].weight;
 
-		if (dist[u] != INT_MAX && dist[u] + w < dist[v])
-		{
-			cout << "Graph contains negative weight cycle. Hence, shortest distance not guaranteed." << endl;
-			return;
-		}
-	}
+        if (dist[u] != INT_MAX && dist[u] + w < dist[v])
+        {
+            cout << "Graph contains negative weight cycle. Hence, shortest "
+                    "distance not guaranteed."
+                 << endl;
+            return;
+        }
+    }
 
-	print(dist, V);
+    print(dist, V);
 
-	return;
+    return;
 }
 
-//Driver Function
+// Driver Function
 int main()
 {
-	int V, E, gsrc;
-	int src, dst, weight;
-	cout << "Enter number of vertices: ";
-	cin >> V;
-	cout << "Enter number of edges: ";
-	cin >> E;
-	Graph G(V, E);
-	for (int i = 0; i < E; i++)
-	{
-		cout << "\nEdge " << i + 1 << "\nEnter source: ";
-		cin >> src;
-		cout << "Enter destination: ";
-		cin >> dst;
-		cout << "Enter weight: ";
-		cin >> weight;
-		G.addEdge(src, dst, weight);
-	}
-	cout << "\nEnter source: ";
-	cin >> gsrc;
-	BellmanFord(G, gsrc);
+    int V, E, gsrc;
+    int src, dst, weight;
+    cout << "Enter number of vertices: ";
+    cin >> V;
+    cout << "Enter number of edges: ";
+    cin >> E;
+    Graph G(V, E);
+    for (int i = 0; i < E; i++)
+    {
+        cout << "\nEdge " << i + 1 << "\nEnter source: ";
+        cin >> src;
+        cout << "Enter destination: ";
+        cin >> dst;
+        cout << "Enter weight: ";
+        cin >> weight;
+        G.addEdge(src, dst, weight);
+    }
+    cout << "\nEnter source: ";
+    cin >> gsrc;
+    BellmanFord(G, gsrc);
 
-	return 0;
+    return 0;
 }
diff --git a/dynamic_programming/catalan_numbers.cpp b/dynamic_programming/catalan_numbers.cpp
index 4d73cd51a..0107b9f20 100644
--- a/dynamic_programming/catalan_numbers.cpp
+++ b/dynamic_programming/catalan_numbers.cpp
@@ -9,7 +9,7 @@
 #include <iostream>
 using namespace std;
 
-int *cat; // global array to hold catalan numbers
+int *cat;  // global array to hold catalan numbers
 
 unsigned long int catalan_dp(int n)
 {
@@ -33,7 +33,7 @@ unsigned long int catalan_dp(int n)
     {
         cat[i] = 0;
         for (int j = 0; j < i; j++)
-            cat[i] += cat[j] * cat[i - j - 1]; // applying the definition here
+            cat[i] += cat[j] * cat[i - j - 1];  // applying the definition here
     }
 
     // Return the result
diff --git a/dynamic_programming/coin_change.cpp b/dynamic_programming/coin_change.cpp
index c8acad48e..f43d4fa18 100644
--- a/dynamic_programming/coin_change.cpp
+++ b/dynamic_programming/coin_change.cpp
@@ -1,50 +1,52 @@
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 // Function to find the Minimum number of coins required to get Sum S
 int findMinCoins(int arr[], int n, int N)
 {
-	// dp[i] = no of coins required to get a total of i
-	int dp[N + 1];
+    // dp[i] = no of coins required to get a total of i
+    int dp[N + 1];
 
-	// 0 coins are needed for 0 sum
+    // 0 coins are needed for 0 sum
 
-	dp[0] = 0;
+    dp[0] = 0;
 
-	for (int i = 1; i <= N; i++)
-	{
-		// initialize minimum number of coins needed to infinity
-		dp[i] = INT_MAX;
-		int res = INT_MAX;
+    for (int i = 1; i <= N; i++)
+    {
+        // initialize minimum number of coins needed to infinity
+        dp[i] = INT_MAX;
+        int res = INT_MAX;
 
-		// do for each coin
-		for (int c = 0; c < n; c++)
-		{
-			if (i - arr[c] >= 0) // check if coins doesn't become negative by including it
-				res = dp[i - arr[c]];
+        // do for each coin
+        for (int c = 0; c < n; c++)
+        {
+            if (i - arr[c] >=
+                0)  // check if coins doesn't become negative by including it
+                res = dp[i - arr[c]];
 
-			// if total can be reached by including current coin c,
-			// update minimum number of coins needed dp[i]
-			if (res != INT_MAX)
-				dp[i] = min(dp[i], res + 1);
-		}
-	}
+            // if total can be reached by including current coin c,
+            // update minimum number of coins needed dp[i]
+            if (res != INT_MAX)
+                dp[i] = min(dp[i], res + 1);
+        }
+    }
 
-	// The Minimum No of Coins Required for N = dp[N]
-	return dp[N];
+    // The Minimum No of Coins Required for N = dp[N]
+    return dp[N];
 }
 
 int main()
 {
-	// No of Coins We Have
-	int arr[] = {1, 2, 3, 4};
-	int n = sizeof(arr) / sizeof(arr[0]);
+    // No of Coins We Have
+    int arr[] = {1, 2, 3, 4};
+    int n = sizeof(arr) / sizeof(arr[0]);
 
-	// Total Change Required
-	int N = 15;
+    // Total Change Required
+    int N = 15;
 
-	cout << "Minimum Number of Coins Required " << findMinCoins(arr, n, N) << "\n";
+    cout << "Minimum Number of Coins Required " << findMinCoins(arr, n, N)
+         << "\n";
 
-	return 0;
+    return 0;
 }
\ No newline at end of file
diff --git a/dynamic_programming/cut_rod.cpp b/dynamic_programming/cut_rod.cpp
index afca3dced..3df0a9fbe 100644
--- a/dynamic_programming/cut_rod.cpp
+++ b/dynamic_programming/cut_rod.cpp
@@ -1,6 +1,6 @@
-/*Given a rod of length n inches and an array of prices that 
-contains prices of all pieces of size smaller than n. Determine 
-the maximum value obtainable by cutting up the rod and selling 
+/*Given a rod of length n inches and an array of prices that
+contains prices of all pieces of size smaller than n. Determine
+the maximum value obtainable by cutting up the rod and selling
 the pieces.*/
 
 #include <iostream>
@@ -22,7 +22,8 @@ int cutrod(int p[], int n)
 }
 int main()
 {
-    int price[] = {1, 5, 8, 9, 10, 17, 17, 20, 24, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
+    int price[] = {1,  5,  8,  9,  10, 17, 17, 20, 24, 30, 31, 32, 33, 34, 35,
+                   36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
     cout << cutrod(price, 30);
     return 0;
 }
diff --git a/dynamic_programming/edit_distance.cpp b/dynamic_programming/edit_distance.cpp
index 996d3272c..da613b238 100644
--- a/dynamic_programming/edit_distance.cpp
+++ b/dynamic_programming/edit_distance.cpp
@@ -7,7 +7,7 @@
  * a. Insert
  * b. Remove
  * c. Replace
- * All of the above operations are 
+ * All of the above operations are
  * of equal cost
  */
 
@@ -15,10 +15,7 @@
 #include <string>
 using namespace std;
 
-int min(int x, int y, int z)
-{
-    return min(min(x, y), z);
-}
+int min(int x, int y, int z) { return min(min(x, y), z); }
 
 /* A Naive recursive C++ program to find
  * minimum number of operations to convert
@@ -32,14 +29,14 @@ int editDist(string str1, string str2, int m, int n)
     if (n == 0)
         return m;
 
-    //If last characters are same then continue
-    //for the rest of them.
+    // If last characters are same then continue
+    // for the rest of them.
     if (str1[m - 1] == str2[n - 1])
         return editDist(str1, str2, m - 1, n - 1);
 
-    //If last not same, then 3 possibilities
-    //a.Insert b.Remove c. Replace
-    //Get min of three and continue for rest.
+    // If last not same, then 3 possibilities
+    // a.Insert b.Remove c. Replace
+    // Get min of three and continue for rest.
     return 1 + min(editDist(str1, str2, m, n - 1),
                    editDist(str1, str2, m - 1, n),
                    editDist(str1, str2, m - 1, n - 1));
@@ -50,31 +47,30 @@ int editDist(string str1, string str2, int m, int n)
  */
 int editDistDP(string str1, string str2, int m, int n)
 {
-
-    //Create Table for SubProblems
+    // Create Table for SubProblems
     int dp[m + 1][n + 1];
 
-    //Fill d[][] in bottom up manner
+    // Fill d[][] in bottom up manner
     for (int i = 0; i <= m; i++)
     {
         for (int j = 0; j <= n; j++)
         {
-            //If str1 empty. Then add all of str2
+            // If str1 empty. Then add all of str2
             if (i == 0)
                 dp[i][j] = j;
 
-            //If str2 empty. Then add all of str1
+            // If str2 empty. Then add all of str1
             else if (j == 0)
                 dp[i][j] = i;
 
-            //If character same. Recur for remaining
+            // If character same. Recur for remaining
             else if (str1[i - 1] == str2[j - 1])
                 dp[i][j] = dp[i - 1][j - 1];
 
             else
-                dp[i][j] = 1 + min(dp[i][j - 1],    //Insert
-                                   dp[i - 1][j],    //Remove
-                                   dp[i - 1][j - 1] //Replace
+                dp[i][j] = 1 + min(dp[i][j - 1],     // Insert
+                                   dp[i - 1][j],     // Remove
+                                   dp[i - 1][j - 1]  // Replace
                                );
         }
     }
diff --git a/dynamic_programming/egg_dropping_puzzle.cpp b/dynamic_programming/egg_dropping_puzzle.cpp
index a441f29cb..79de4cc22 100644
--- a/dynamic_programming/egg_dropping_puzzle.cpp
+++ b/dynamic_programming/egg_dropping_puzzle.cpp
@@ -1,9 +1,9 @@
-/* Function to get minimun number of trials needed 
- * in worst case with n eggs and k floors 
+/* Function to get minimun number of trials needed
+ * in worst case with n eggs and k floors
  */
 
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 int eggDrop(int n, int k)
@@ -13,8 +13,8 @@ int eggDrop(int n, int k)
 
     for (int i = 1; i <= n; i++)
     {
-        eggFloor[i][1] = 1; //n eggs..1 Floor
-        eggFloor[i][0] = 0; //n eggs..0 Floor
+        eggFloor[i][1] = 1;  // n eggs..1 Floor
+        eggFloor[i][0] = 0;  // n eggs..0 Floor
     }
 
     // Only one egg available
diff --git a/dynamic_programming/fibonacci_bottom_up.cpp b/dynamic_programming/fibonacci_bottom_up.cpp
index ab5b5b41f..3a9669fa9 100644
--- a/dynamic_programming/fibonacci_bottom_up.cpp
+++ b/dynamic_programming/fibonacci_bottom_up.cpp
@@ -2,23 +2,23 @@
 using namespace std;
 int fib(int n)
 {
-	int res[3];
-	res[0] = 0;
-	res[1] = 1;
-	for (int i = 2; i <= n; i++)
-	{
-		res[2] = res[1] + res[0];
-		res[0] = res[1];
-		res[1] = res[2];
-	}
-	return res[1];
+    int res[3];
+    res[0] = 0;
+    res[1] = 1;
+    for (int i = 2; i <= n; i++)
+    {
+        res[2] = res[1] + res[0];
+        res[0] = res[1];
+        res[1] = res[2];
+    }
+    return res[1];
 }
 int main(int argc, char const *argv[])
 {
-	int n;
-	cout << "Enter n: ";
-	cin >> n;
-	cout << "Fibonacci number is ";
-	cout << fib(n) << endl;
-	return 0;
+    int n;
+    cout << "Enter n: ";
+    cin >> n;
+    cout << "Fibonacci number is ";
+    cout << fib(n) << endl;
+    return 0;
 }
diff --git a/dynamic_programming/fibonacci_top_down.cpp b/dynamic_programming/fibonacci_top_down.cpp
index 9d76366f7..3ac3fdb40 100644
--- a/dynamic_programming/fibonacci_top_down.cpp
+++ b/dynamic_programming/fibonacci_top_down.cpp
@@ -3,24 +3,24 @@ using namespace std;
 int arr[1000000];
 int fib(int n)
 {
-	if (arr[n] == -1)
-	{
-		if (n <= 1)
-			arr[n] = n;
-		else
-			arr[n] = fib(n - 1) + fib(n - 2);
-	}
-	return arr[n];
+    if (arr[n] == -1)
+    {
+        if (n <= 1)
+            arr[n] = n;
+        else
+            arr[n] = fib(n - 1) + fib(n - 2);
+    }
+    return arr[n];
 }
 int main(int argc, char const *argv[])
 {
-	int n;
-	cout << "Enter n: ";
-	cin >> n;
-	for (int i = 0; i < n + 1; ++i)
-	{
-		arr[i] = -1;
-	}
-	cout << "Fibonacci number is " << fib(n) << endl;
-	return 0;
+    int n;
+    cout << "Enter n: ";
+    cin >> n;
+    for (int i = 0; i < n + 1; ++i)
+    {
+        arr[i] = -1;
+    }
+    cout << "Fibonacci number is " << fib(n) << endl;
+    return 0;
 }
\ No newline at end of file
diff --git a/dynamic_programming/floyd_warshall.cpp b/dynamic_programming/floyd_warshall.cpp
index 93ccff62f..e3b0c66d3 100644
--- a/dynamic_programming/floyd_warshall.cpp
+++ b/dynamic_programming/floyd_warshall.cpp
@@ -1,112 +1,110 @@
-#include <iostream>
 #include <limits.h>
 #include <string.h>
+#include <iostream>
 
 using namespace std;
 
-//Wrapper class for storing a graph
+// Wrapper class for storing a graph
 class Graph
 {
-public:
-	int vertexNum;
-	int **edges;
+ public:
+    int vertexNum;
+    int **edges;
 
-	//Constructs a graph with V vertices and E edges
-	Graph(int V)
-	{
-		this->vertexNum = V;
-		this->edges = (int **)malloc(V * sizeof(int *));
-		for (int i = 0; i < V; i++)
-		{
-			this->edges[i] = (int *)malloc(V * sizeof(int));
-			for (int j = 0; j < V; j++)
-				this->edges[i][j] = INT_MAX;
-			this->edges[i][i] = 0;
-		}
-	}
+    // Constructs a graph with V vertices and E edges
+    Graph(int V)
+    {
+        this->vertexNum = V;
+        this->edges = (int **)malloc(V * sizeof(int *));
+        for (int i = 0; i < V; i++)
+        {
+            this->edges[i] = (int *)malloc(V * sizeof(int));
+            for (int j = 0; j < V; j++) this->edges[i][j] = INT_MAX;
+            this->edges[i][i] = 0;
+        }
+    }
 
-	//Adds the given edge to the graph
-	void addEdge(int src, int dst, int weight)
-	{
-		this->edges[src][dst] = weight;
-	}
+    // Adds the given edge to the graph
+    void addEdge(int src, int dst, int weight)
+    {
+        this->edges[src][dst] = weight;
+    }
 };
 
-//Utility function to print distances
+// Utility function to print distances
 void print(int dist[], int V)
 {
-	cout << "\nThe Distance matrix for Floyd - Warshall" << endl;
-	for (int i = 0; i < V; i++)
-	{
-		for (int j = 0; j < V; j++)
-		{
-
-			if (dist[i * V + j] != INT_MAX)
-				cout << dist[i * V + j] << "\t";
-			else
-				cout << "INF"
-					 << "\t";
-		}
-		cout << endl;
-	}
+    cout << "\nThe Distance matrix for Floyd - Warshall" << endl;
+    for (int i = 0; i < V; i++)
+    {
+        for (int j = 0; j < V; j++)
+        {
+            if (dist[i * V + j] != INT_MAX)
+                cout << dist[i * V + j] << "\t";
+            else
+                cout << "INF"
+                     << "\t";
+        }
+        cout << endl;
+    }
 }
 
-//The main function that finds the shortest path from a vertex
-//to all other vertices using Floyd-Warshall Algorithm.
+// The main function that finds the shortest path from a vertex
+// to all other vertices using Floyd-Warshall Algorithm.
 void FloydWarshall(Graph graph)
 {
-	int V = graph.vertexNum;
-	int dist[V][V];
+    int V = graph.vertexNum;
+    int dist[V][V];
 
-	//Initialise distance array
-	for (int i = 0; i < V; i++)
-		for (int j = 0; j < V; j++)
-			dist[i][j] = graph.edges[i][j];
+    // Initialise distance array
+    for (int i = 0; i < V; i++)
+        for (int j = 0; j < V; j++) dist[i][j] = graph.edges[i][j];
 
-	//Calculate distances
-	for (int k = 0; k < V; k++)
-		//Choose an intermediate vertex
+    // Calculate distances
+    for (int k = 0; k < V; k++)
+        // Choose an intermediate vertex
 
-		for (int i = 0; i < V; i++)
-			//Choose a source vertex for given intermediate
+        for (int i = 0; i < V; i++)
+            // Choose a source vertex for given intermediate
 
-			for (int j = 0; j < V; j++)
-				//Choose a destination vertex for above source vertex
+            for (int j = 0; j < V; j++)
+                // Choose a destination vertex for above source vertex
 
-				if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX && dist[i][k] + dist[k][j] < dist[i][j])
-					//If the distance through intermediate vertex is less than direct edge then update value in distance array
-					dist[i][j] = dist[i][k] + dist[k][j];
+                if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX &&
+                    dist[i][k] + dist[k][j] < dist[i][j])
+                    // If the distance through intermediate vertex is less than
+                    // direct edge then update value in distance array
+                    dist[i][j] = dist[i][k] + dist[k][j];
 
-	//Convert 2d array to 1d array for print
-	int dist1d[V * V];
-	for (int i = 0; i < V; i++)
-		for (int j = 0; j < V; j++)
-			dist1d[i * V + j] = dist[i][j];
+    // Convert 2d array to 1d array for print
+    int dist1d[V * V];
+    for (int i = 0; i < V; i++)
+        for (int j = 0; j < V; j++) dist1d[i * V + j] = dist[i][j];
 
-	print(dist1d, V);
+    print(dist1d, V);
 }
 
-//Driver Function
+// Driver Function
 int main()
 {
-	int V, E;
-	int src, dst, weight;
-	cout << "Enter number of vertices: ";
-	cin >> V;
-	cout << "Enter number of edges: ";
-	cin >> E;
-	Graph G(V);
-	for (int i = 0; i < E; i++)
-	{
-		cout << "\nEdge " << i + 1 << "\nEnter source: ";
-		cin >> src;
-		cout << "Enter destination: ";
-		cin >> dst;
-		cout << "Enter weight: ";
-		cin >> weight;
-		G.addEdge(src, dst, weight);
-	}
-	FloydWarshall(G);
+    int V, E;
+    int src, dst, weight;
+    cout << "Enter number of vertices: ";
+    cin >> V;
+    cout << "Enter number of edges: ";
+    cin >> E;
+    Graph G(V);
+    for (int i = 0; i < E; i++)
+    {
+        cout << "\nEdge " << i + 1 << "\nEnter source: ";
+        cin >> src;
+        cout << "Enter destination: ";
+        cin >> dst;
+        cout << "Enter weight: ";
+        cin >> weight;
+        G.addEdge(src, dst, weight);
+    }
+    FloydWarshall(G);
 
-	return 0;
+    return 0;
 }
diff --git a/dynamic_programming/kadane.cpp b/dynamic_programming/kadane.cpp
index bf2aa76ac..31d17ae9e 100644
--- a/dynamic_programming/kadane.cpp
+++ b/dynamic_programming/kadane.cpp
@@ -1,10 +1,12 @@
-#include<iostream>
-#include<climits>
+#include <climits>
+#include <iostream>
 
-int maxSubArraySum(int a[], int size) {
+int maxSubArraySum(int a[], int size)
+{
     int max_so_far = INT_MIN, max_ending_here = 0;
 
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++)
+    {
         max_ending_here = max_ending_here + a[i];
         if (max_so_far < max_ending_here)
             max_so_far = max_ending_here;
@@ -15,13 +17,14 @@ int maxSubArraySum(int a[], int size) {
     return max_so_far;
 }
 
-
-int main() {
+int main()
+{
     int n, i;
     std::cout << "Enter the number of elements \n";
     std::cin >> n;
     int a[n];  // NOLINT
-    for (i = 0; i < n; i++) {
+    for (i = 0; i < n; i++)
+    {
         std::cin >> a[i];
     }
     int max_sum = maxSubArraySum(a, n);
diff --git a/dynamic_programming/longest_common_string.cpp b/dynamic_programming/longest_common_string.cpp
index c1e89d6db..e33489cb1 100644
--- a/dynamic_programming/longest_common_string.cpp
+++ b/dynamic_programming/longest_common_string.cpp
@@ -1,65 +1,59 @@
 #include <iosrteam>
 using namespace std;
 
-int max(int a,int b)
-{
-    return (a > b) ? a : b;
-}
+int max(int a, int b) { return (a > b) ? a : b; }
 
 int main()
 {
-    char str1[]="DEFBCD";
-    char str2[]="ABDEFJ";
-    int i,j,k;
-    int n=strlen(str1)+1;
-    int m=strlen(str2)+1;
-    //cout<<n<<" "<<m<<"\n";
+    char str1[] = "DEFBCD";
+    char str2[] = "ABDEFJ";
+    int i, j, k;
+    int n = strlen(str1) + 1;
+    int m = strlen(str2) + 1;
+    // cout<<n<<" "<<m<<"\n";
     int a[m][n];
 
-    for(i=0;i<m;i++)
+    for (i = 0; i < m; i++)
     {
-        for(j=0;j<n;j++)
+        for (j = 0; j < n; j++)
         {
-            if(i==0 || j==0)
-                a[i][j]=0;
+            if (i == 0 || j == 0)
+                a[i][j] = 0;
 
-            else if(str1[i-1] == str2[j-1])
-                    a[i][j]=a[i-1][j-1]+1;
+            else if (str1[i - 1] == str2[j - 1])
+                a[i][j] = a[i - 1][j - 1] + 1;
 
             else
-                a[i][j]=0;
+                a[i][j] = 0;
         }
     }
 
-
-/*for(i=0;i<m;i++)
-    {
-        for(j=0;j<n;j++)
-            cout<<a[i][j]<<" ";
-        cout<<"\n";
-    }*/
-
-
-int ma=-1;
-int indi,indj;
-for(i=0;i<m;i++)
-    {
-        for(j=0;j<n;j++)
+    /*for(i=0;i<m;i++)
         {
-            if(a[i][j]>ma)
+            for(j=0;j<n;j++)
+                cout<<a[i][j]<<" ";
+            cout<<"\n";
+        }*/
+
+    int ma = -1;
+    int indi, indj;
+    for (i = 0; i < m; i++)
+    {
+        for (j = 0; j < n; j++)
+        {
+            if (a[i][j] > ma)
             {
-                ma=a[i][j];
-                indi=i;
-                indj=j;
+                ma = a[i][j];
+                indi = i;
+                indj = j;
             }
         }
     }
 
-    cout<<str1<<"\n";
-    cout<<str2<<"\n";
+    cout << str1 << "\n";
+    cout << str2 << "\n";
 
-    cout<<"longest string size = "<<ma/*<<" "<<indi<<" "<<indj*/<<"\n";
-    for(i=indi-3;i<indi;i++)
-        cout<<str1[i];
-    cout<<"\n";
+    cout << "longest string size = " << ma /*<<" "<<indi<<" "<<indj*/ << "\n";
+    for (i = indi - 3; i < indi; i++) cout << str1[i];
+    cout << "\n";
 }
diff --git a/dynamic_programming/longest_common_subsequence.cpp b/dynamic_programming/longest_common_subsequence.cpp
index af50720b4..7973bb05e 100644
--- a/dynamic_programming/longest_common_subsequence.cpp
+++ b/dynamic_programming/longest_common_subsequence.cpp
@@ -1,4 +1,4 @@
-//Longest common subsequence - Dynamic Programming
+// Longest common subsequence - Dynamic Programming
 #include <iostream>
 using namespace std;
 
@@ -52,19 +52,22 @@ int lcs(string a, string b)
             else if (a[i - 1] == b[j - 1])
             {
                 res[i][j] = 1 + res[i - 1][j - 1];
-                trace[i][j] = 1; // 1 means trace the matrix in upper left diagonal direction.
+                trace[i][j] = 1;  // 1 means trace the matrix in upper left
+                                  // diagonal direction.
             }
             else
             {
                 if (res[i - 1][j] > res[i][j - 1])
                 {
                     res[i][j] = res[i - 1][j];
-                    trace[i][j] = 2; // 2 means trace the matrix in upwards direction.
+                    trace[i][j] =
+                        2;  // 2 means trace the matrix in upwards direction.
                 }
                 else
                 {
                     res[i][j] = res[i][j - 1];
-                    trace[i][j] = 3; //  means trace the matrix in left direction.
+                    trace[i][j] =
+                        3;  //  means trace the matrix in left direction.
                 }
             }
         }
diff --git a/dynamic_programming/longest_increasing_subsequence.cpp b/dynamic_programming/longest_increasing_subsequence.cpp
index 49c54a941..573db34a5 100644
--- a/dynamic_programming/longest_increasing_subsequence.cpp
+++ b/dynamic_programming/longest_increasing_subsequence.cpp
@@ -1,39 +1,39 @@
-//Program to calculate length of longest increasing subsequence in an array
+// Program to calculate length of longest increasing subsequence in an array
 #include <bits/stdc++.h>
 using namespace std;
 int LIS(int a[], int n)
 {
-	int lis[n];
-	for (int i = 0; i < n; ++i)
-	{
-		lis[i] = 1;
-	}
-	for (int i = 0; i < n; ++i)
-	{
-		for (int j = 0; j < i; ++j)
-		{
-			if (a[i] > a[j] && lis[i] < lis[j] + 1)
-				lis[i] = lis[j] + 1;
-		}
-	}
-	int res = 0;
-	for (int i = 0; i < n; ++i)
-	{
-		res = max(res, lis[i]);
-	}
-	return res;
+    int lis[n];
+    for (int i = 0; i < n; ++i)
+    {
+        lis[i] = 1;
+    }
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 0; j < i; ++j)
+        {
+            if (a[i] > a[j] && lis[i] < lis[j] + 1)
+                lis[i] = lis[j] + 1;
+        }
+    }
+    int res = 0;
+    for (int i = 0; i < n; ++i)
+    {
+        res = max(res, lis[i]);
+    }
+    return res;
 }
 int main(int argc, char const *argv[])
 {
-	int n;
-	cout << "Enter size of array: ";
-	cin >> n;
-	int a[n];
-	cout << "Enter array elements: ";
-	for (int i = 0; i < n; ++i)
-	{
-		cin >> a[i];
-	}
-	cout << LIS(a, n) << endl;
-	return 0;
+    int n;
+    cout << "Enter size of array: ";
+    cin >> n;
+    int a[n];
+    cout << "Enter array elements: ";
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> a[i];
+    }
+    cout << LIS(a, n) << endl;
+    return 0;
 }
\ No newline at end of file
diff --git a/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp b/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
index 5ee24e6a7..2471b701f 100644
--- a/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
+++ b/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
@@ -1,4 +1,4 @@
-//Program to calculate length of longest increasing subsequence in an array
+// Program to calculate length of longest increasing subsequence in an array
 // in O(n log n)
 // tested on : https://cses.fi/problemset/task/1145/
 
@@ -7,30 +7,32 @@
 using namespace std;
 int LIS(int arr[], int n)
 {
-    set < int > active; // The current built LIS.
+    set<int> active;  // The current built LIS.
     active.insert(arr[0]);
     // Loop through every element.
     for (int i = 1; i < n; ++i)
     {
         auto get = active.lower_bound(arr[i]);
         if (get == active.end())
-	{
+        {
             active.insert(arr[i]);
-        } // current element is the greatest so LIS increases by 1.
+        }  // current element is the greatest so LIS increases by 1.
         else
-	{
-            int val = * get; // we find the position where arr[i] will be in the LIS. If it is in the LIS already we do nothing
+        {
+            int val = *get;  // we find the position where arr[i] will be in the
+                             // LIS. If it is in the LIS already we do nothing
             if (val > arr[i])
-	    {
-                // else we remove the bigger element and add a smaller element (which is arr[i]) and continue;
+            {
+                // else we remove the bigger element and add a smaller element
+                // (which is arr[i]) and continue;
                 active.erase(get);
                 active.insert(arr[i]);
             }
         }
     }
-    return active.size(); // size of the LIS.
+    return active.size();  // size of the LIS.
 }
-int main(int argc, char const * argv[])
+int main(int argc, char const* argv[])
 {
     int n;
     cout << "Enter size of array: ";
diff --git a/dynamic_programming/matrix_chain_multiplication.cpp b/dynamic_programming/matrix_chain_multiplication.cpp
index 1e885bd7e..378edcc7f 100644
--- a/dynamic_programming/matrix_chain_multiplication.cpp
+++ b/dynamic_programming/matrix_chain_multiplication.cpp
@@ -1,5 +1,5 @@
-#include <iostream>
 #include <climits>
+#include <iostream>
 using namespace std;
 
 #define MAX 10
@@ -7,56 +7,59 @@ using namespace std;
 // dp table to store the solution for already computed sub problems
 int dp[MAX][MAX];
 
-// Function to find the most efficient way to multiply the given sequence of matrices
+// Function to find the most efficient way to multiply the given sequence of
+// matrices
 int MatrixChainMultiplication(int dim[], int i, int j)
 {
-	// base case: one matrix
-	if (j <= i + 1)
-		return 0;
+    // base case: one matrix
+    if (j <= i + 1)
+        return 0;
 
-	// stores minimum number of scalar multiplications (i.e., cost)
-	// needed to compute the matrix M[i+1]...M[j] = M[i..j]
-	int min = INT_MAX;
+    // stores minimum number of scalar multiplications (i.e., cost)
+    // needed to compute the matrix M[i+1]...M[j] = M[i..j]
+    int min = INT_MAX;
 
-	// if dp[i][j] is not calculated (calculate it!!)
+    // if dp[i][j] is not calculated (calculate it!!)
 
-	if (dp[i][j] == 0)
-	{
-		// take the minimum over each possible position at which the
-		// sequence of matrices can be split
+    if (dp[i][j] == 0)
+    {
+        // take the minimum over each possible position at which the
+        // sequence of matrices can be split
 
-		for (int k = i + 1; k <= j - 1; k++)
-		{
-			// recur for M[i+1]..M[k] to get a i x k matrix
-			int cost = MatrixChainMultiplication(dim, i, k);
+        for (int k = i + 1; k <= j - 1; k++)
+        {
+            // recur for M[i+1]..M[k] to get a i x k matrix
+            int cost = MatrixChainMultiplication(dim, i, k);
 
-			// recur for M[k+1]..M[j] to get a k x j matrix
-			cost += MatrixChainMultiplication(dim, k, j);
+            // recur for M[k+1]..M[j] to get a k x j matrix
+            cost += MatrixChainMultiplication(dim, k, j);
 
-			// cost to multiply two (i x k) and (k x j) matrix
-			cost += dim[i] * dim[k] * dim[j];
+            // cost to multiply two (i x k) and (k x j) matrix
+            cost += dim[i] * dim[k] * dim[j];
 
-			if (cost < min)
-				min = cost; // store the minimum cost
-		}
-		dp[i][j] = min;
-	}
+            if (cost < min)
+                min = cost;  // store the minimum cost
+        }
+        dp[i][j] = min;
+    }
 
-	// return min cost to multiply M[j+1]..M[j]
-	return dp[i][j];
+    // return min cost to multiply M[j+1]..M[j]
+    return dp[i][j];
 }
 
 // main function
 int main()
 {
-	// Matrix i has Dimensions dim[i-1] & dim[i] for i=1..n
-	// input is 10 x 30 matrix, 30 x 5 matrix, 5 x 60 matrix
-	int dim[] = {10, 30, 5, 60};
-	int n = sizeof(dim) / sizeof(dim[0]);
+    // Matrix i has Dimensions dim[i-1] & dim[i] for i=1..n
+    // input is 10 x 30 matrix, 30 x 5 matrix, 5 x 60 matrix
+    int dim[] = {10, 30, 5, 60};
+    int n = sizeof(dim) / sizeof(dim[0]);
 
-	// Function Calling: MatrixChainMultiplications(dimensions_array, starting, ending);
+    // Function Calling: MatrixChainMultiplications(dimensions_array, starting,
+    // ending);
 
-	cout << "Minimum cost is " << MatrixChainMultiplication(dim, 0, n - 1) << "\n";
+    cout << "Minimum cost is " << MatrixChainMultiplication(dim, 0, n - 1)
+         << "\n";
 
-	return 0;
+    return 0;
 }
\ No newline at end of file
diff --git a/dynamic_programming/searching_of_element_in_dynamic_array.cpp b/dynamic_programming/searching_of_element_in_dynamic_array.cpp
index 9ee48dded..3dea46bf4 100644
--- a/dynamic_programming/searching_of_element_in_dynamic_array.cpp
+++ b/dynamic_programming/searching_of_element_in_dynamic_array.cpp
@@ -1,41 +1,42 @@
 /*
-*this program is use to find any elemet in any row with variable array size
-*aplication of pointer is use in it
-*important point start from here to:
-*the index value of array can be go to 1 to 100000
-*check till array[1000]
-*end here
-*how to work example:
-**Question:
-***number of array 2
-***quarry 3
-***array 1 is {1 2 3 4 5}
-***array 2 is {6 7}
-****i) what is 2nd element in 1st array
-****ii) what is 1st element in 2nd array
-****iii) what is 5th element in 1st array
-*****output:
-*****Enter Number of array you want to Store : 2
-*****Enter Number of Question or Quary you want to do Related to Array : 3
-*****Enter number of element in 1 rows : 5
-*****Enter the element of Array 1 2 3 4 5
-*****Enter number of element in 2 rows : 2
-*****Enter the element of Array 6 7
-*****enter the number of row which element You want to find : 1
-*****enter the position of element which You want to find : 2
-*****The element is 2
-*****enter the number of row which element You want to find : 2
-*****enter the position of element which You want to find : 1
-*****The element is 6
-*****enter the number of row which element You want to find : 1
-*****enter the position of element which You want to find : 5
-*****The element is 5
-*/
+ *this program is use to find any elemet in any row with variable array size
+ *aplication of pointer is use in it
+ *important point start from here to:
+ *the index value of array can be go to 1 to 100000
+ *check till array[1000]
+ *end here
+ *how to work example:
+ **Question:
+ ***number of array 2
+ ***quarry 3
+ ***array 1 is {1 2 3 4 5}
+ ***array 2 is {6 7}
+ ****i) what is 2nd element in 1st array
+ ****ii) what is 1st element in 2nd array
+ ****iii) what is 5th element in 1st array
+ *****output:
+ *****Enter Number of array you want to Store : 2
+ *****Enter Number of Question or Quary you want to do Related to Array : 3
+ *****Enter number of element in 1 rows : 5
+ *****Enter the element of Array 1 2 3 4 5
+ *****Enter number of element in 2 rows : 2
+ *****Enter the element of Array 6 7
+ *****enter the number of row which element You want to find : 1
+ *****enter the position of element which You want to find : 2
+ *****The element is 2
+ *****enter the number of row which element You want to find : 2
+ *****enter the position of element which You want to find : 1
+ *****The element is 6
+ *****enter the number of row which element You want to find : 1
+ *****enter the position of element which You want to find : 5
+ *****The element is 5
+ */
 #include <iostream>
 
 // this is main fuction
 // ***
-int main() {
+int main()
+{
     int64_t r, mr = 0, x, q, i, z;
     std::cout << "Enter Number of array you want to Store :";
     std::cin >> x;
@@ -46,10 +47,11 @@ int main() {
     // create a Array in run time because use can
     // change the size of each array which he/she is going to store
     // create a 2D array
-    int** ar = new int* [x]();
+    int** ar = new int*[x]();
     // this for loop is use for entering different variable size array
     // ***
-    for (r = 0; r < x; r++) {
+    for (r = 0; r < x; r++)
+    {
         std::cout << "Enter number of element in " << r + 1 << " rows :";
         std::cin >> mr;
         // creating a 1D array
@@ -57,7 +59,8 @@ int main() {
         std::cout << "Enter the element of Array ";
         // this for loop is use for storing values in array
         // ***
-        for (i = 0; i < mr; i++) {
+        for (i = 0; i < mr; i++)
+        {
             // entering the value of rows in array in Horizontal
             std::cin >> ac[i];
         }
@@ -66,7 +69,8 @@ int main() {
     }
     // this for loop is use for display result of querry
     // ***
-    for (z = 0; z < q; z++) {
+    for (z = 0; z < q; z++)
+    {
         int64_t r1 = 0, q1 = 0;
         std::cout << "enter the number of row which element you want to find :";
         std::cin >> r1;
@@ -75,6 +79,6 @@ int main() {
         std::cin >> q1;
         q1 = q1 - 1;
         // use this to find desire position of element in desire array
-        std::cout <<"The element is "<< ar[r1][q1] <<std::endl;
+        std::cout << "The element is " << ar[r1][q1] << std::endl;
     }
 }
diff --git a/dynamic_programming/tree_height.cpp b/dynamic_programming/tree_height.cpp
index 6acc15959..1530dfe7e 100644
--- a/dynamic_programming/tree_height.cpp
+++ b/dynamic_programming/tree_height.cpp
@@ -8,18 +8,18 @@
  * 1 2
  * 1 3
  * 2 4
- * which can be represented as                 
- *   1                      
- *  / \                     
- * 2   3                    
- * |                        
- * 4            
- * 
+ * which can be represented as
+ *   1
+ *  / \
+ * 2   3
+ * |
+ * 4
+ *
  * Height of the tree : - 2
-*/
+ */
 
-#include<iostream>
-#include<vector>
+#include <iostream>
+#include <vector>
 
 // global declarations
 // no of nodes max limit.
@@ -29,22 +29,26 @@ std::vector<int> adj[MAX];
 std::vector<bool> visited;
 std::vector<int> dp;
 
-void depth_first_search(int u) {
+void depth_first_search(int u)
+{
     visited[u] = true;
     int child_height = 1;
-    for (int v : adj[u]) {
-        if (!visited[v]) {
+    for (int v : adj[u])
+    {
+        if (!visited[v])
+        {
             depth_first_search(v);
 
             // select maximum sub-tree height from all children.
-            child_height = std::max(child_height, dp[v]+1);
+            child_height = std::max(child_height, dp[v] + 1);
         }
     }
     // assigned the max child height to current visited node.
     dp[u] = child_height;
 }
 
-int main() {
+int main()
+{
     // number of nodes
     int number_of_nodes;
     std::cout << "Enter number of nodes of the tree : " << std::endl;
@@ -54,16 +58,17 @@ int main() {
     int u, v;
     // Tree contains exactly n-1 edges where n denotes the number of nodes.
     std::cout << "Enter edges of the tree : " << std::endl;
-    for (int i = 0; i < number_of_nodes - 1; i++) {
+    for (int i = 0; i < number_of_nodes - 1; i++)
+    {
         std::cin >> u >> v;
         // undirected tree u -> v and v -> u.
         adj[u].push_back(v);
         adj[v].push_back(u);
     }
     // initialize all nodes as unvisited.
-    visited.assign(number_of_nodes+1, false);
+    visited.assign(number_of_nodes + 1, false);
     // initialize depth of all nodes to 0.
-    dp.assign(number_of_nodes+1, 0);
+    dp.assign(number_of_nodes + 1, 0);
     // function call which will initialize the height of all nodes.
     depth_first_search(1);
     std::cout << "Height of the Tree : " << dp[1] << std::endl;
diff --git a/graph/bfs.cpp b/graph/bfs.cpp
index e4e12886b..f5d372134 100644
--- a/graph/bfs.cpp
+++ b/graph/bfs.cpp
@@ -2,72 +2,72 @@
 using namespace std;
 class graph
 {
-	int v;
-	list<int> *adj;
+    int v;
+    list<int> *adj;
 
-public:
-	graph(int v);
-	void addedge(int src, int dest);
-	void printgraph();
-	void bfs(int s);
+ public:
+    graph(int v);
+    void addedge(int src, int dest);
+    void printgraph();
+    void bfs(int s);
 };
 graph::graph(int v)
 {
-	this->v = v;
-	this->adj = new list<int>[v];
+    this->v = v;
+    this->adj = new list<int>[v];
 }
 void graph::addedge(int src, int dest)
 {
-	src--;
-	dest--;
-	adj[src].push_back(dest);
-	//adj[dest].push_back(src);
+    src--;
+    dest--;
+    adj[src].push_back(dest);
+    // adj[dest].push_back(src);
 }
 void graph::printgraph()
 {
-	for (int i = 0; i < this->v; i++)
-	{
-		cout << "Adjacency list of vertex " << i + 1 << " is \n";
-		list<int>::iterator it;
-		for (it = adj[i].begin(); it != adj[i].end(); ++it)
-		{
-			cout << *it + 1 << " ";
-		}
-		cout << endl;
-	}
+    for (int i = 0; i < this->v; i++)
+    {
+        cout << "Adjacency list of vertex " << i + 1 << " is \n";
+        list<int>::iterator it;
+        for (it = adj[i].begin(); it != adj[i].end(); ++it)
+        {
+            cout << *it + 1 << " ";
+        }
+        cout << endl;
+    }
 }
 void graph::bfs(int s)
 {
-	bool *visited = new bool[this->v + 1];
-	memset(visited, false, sizeof(bool) * (this->v + 1));
-	visited[s] = true;
-	list<int> q;
-	q.push_back(s);
-	list<int>::iterator it;
-	while (!q.empty())
-	{
-		int u = q.front();
-		cout << u << " ";
-		q.pop_front();
-		for (it = adj[u].begin(); it != adj[u].end(); ++it)
-		{
-			if (visited[*it] == false)
-			{
-				visited[*it] = true;
-				q.push_back(*it);
-			}
-		}
-	}
+    bool *visited = new bool[this->v + 1];
+    memset(visited, false, sizeof(bool) * (this->v + 1));
+    visited[s] = true;
+    list<int> q;
+    q.push_back(s);
+    list<int>::iterator it;
+    while (!q.empty())
+    {
+        int u = q.front();
+        cout << u << " ";
+        q.pop_front();
+        for (it = adj[u].begin(); it != adj[u].end(); ++it)
+        {
+            if (visited[*it] == false)
+            {
+                visited[*it] = true;
+                q.push_back(*it);
+            }
+        }
+    }
 }
 int main()
 {
-	graph g(4);
-	g.addedge(1, 2);
-	g.addedge(2, 3);
-	g.addedge(3, 4);
-	g.addedge(1, 4);
-	g.addedge(1, 3);
-	//g.printgraph();
-	g.bfs(2);
-	return 0;
+    graph g(4);
+    g.addedge(1, 2);
+    g.addedge(2, 3);
+    g.addedge(3, 4);
+    g.addedge(1, 4);
+    g.addedge(1, 3);
+    // g.printgraph();
+    g.bfs(2);
+    return 0;
 }
diff --git a/graph/bridge_finding_with_tarjan_algorithm.cpp b/graph/bridge_finding_with_tarjan_algorithm.cpp
index ca124f512..a283a7c91 100644
--- a/graph/bridge_finding_with_tarjan_algorithm.cpp
+++ b/graph/bridge_finding_with_tarjan_algorithm.cpp
@@ -4,28 +4,34 @@
  *  Last Modified Date: May 24, 2020
  *
  */
-#include <vector>  //  for std::vector
 #include <algorithm>  //  for min & max
-#include <iostream>  //  for cout
-using std::vector;
+#include <iostream>   //  for cout
+#include <vector>     //  for std::vector
 using std::cout;
 using std::min;
-class Solution {
-    vector < vector < int > > graph;
-    vector<int>in_time , out_time;
+using std::vector;
+class Solution
+{
+    vector<vector<int>> graph;
+    vector<int> in_time, out_time;
     int timer;
-    vector < vector < int > > bridge;
-    vector<bool>visited;
-    void dfs(int current_node , int parent) {
+    vector<vector<int>> bridge;
+    vector<bool> visited;
+    void dfs(int current_node, int parent)
+    {
         visited.at(current_node) = true;
         in_time[current_node] = out_time[current_node] = timer++;
-        for ( auto&itr : graph[current_node] ) {
-            if (itr == parent) {
+        for (auto& itr : graph[current_node])
+        {
+            if (itr == parent)
+            {
                 continue;
             }
-            if (!visited[itr]) {
-                dfs(itr , current_node);
-                if (out_time[itr] > in_time[current_node]) {
+            if (!visited[itr])
+            {
+                dfs(itr, current_node);
+                if (out_time[itr] > in_time[current_node])
+                {
                     bridge.push_back({itr, current_node});
                 }
             }
@@ -34,14 +40,16 @@ class Solution {
     }
 
  public:
-    vector <vector <int> > search_bridges(int n,
-            const vector<vector<int>>& connections) {
+    vector<vector<int>> search_bridges(int n,
+                                       const vector<vector<int>>& connections)
+    {
         timer = 0;
         graph.resize(n);
         in_time.assign(n, 0);
         visited.assign(n, false);
         out_time.assign(n, 0);
-        for (auto&itr : connections) {
+        for (auto& itr : connections)
+        {
             graph.at(itr[0]).push_back(itr[1]);
             graph.at(itr[1]).push_back(itr[0]);
         }
@@ -49,10 +57,11 @@ class Solution {
         return bridge;
     }
 };
-int main(void) {
+int main(void)
+{
     Solution s1;
     int number_of_node = 5;
-    vector< vector <int> >node;
+    vector<vector<int>> node;
     node.push_back({0, 1});
     node.push_back({1, 3});
     node.push_back({1, 2});
@@ -66,13 +75,14 @@ int main(void) {
      *            3       4
      *
      *    In this graph there are 4 bridges [0,2] , [2,4] , [3,5] , [1,2]
-     *    
+     *
      *    I assumed that the graph is bi-directional and connected.
      *
      */
-    vector< vector <int> > bridges = s1.search_bridges(number_of_node , node);
+    vector<vector<int>> bridges = s1.search_bridges(number_of_node, node);
     cout << bridges.size() << " bridges found!\n";
-    for (auto&itr : bridges) {
+    for (auto& itr : bridges)
+    {
         cout << itr[0] << " --> " << itr[1] << '\n';
     }
     return 0;
diff --git a/graph/connected_components.cpp b/graph/connected_components.cpp
index 9c22cc35e..f78ef011e 100644
--- a/graph/connected_components.cpp
+++ b/graph/connected_components.cpp
@@ -3,53 +3,62 @@
 
 using std::vector;
 
-class graph {
+class graph
+{
  private:
     vector<vector<int>> adj;
     int connected_components;
     void depth_first_search();
-    void explore(int, vector<bool>&);
+    void explore(int, vector<bool> &);
+
  public:
-    explicit graph(int n): adj(n, vector<int>()) {
-      connected_components = 0;
-    }
+    explicit graph(int n) : adj(n, vector<int>()) { connected_components = 0; }
     void addEdge(int, int);
-    int getConnectedComponents() {
-      depth_first_search();
-      return connected_components;
+    int getConnectedComponents()
+    {
+        depth_first_search();
+        return connected_components;
     }
 };
 
-void graph::addEdge(int u, int v) {
-  adj[u-1].push_back(v-1);
-  adj[v-1].push_back(u-1);
+void graph::addEdge(int u, int v)
+{
+    adj[u - 1].push_back(v - 1);
+    adj[v - 1].push_back(u - 1);
 }
 
-void graph::depth_first_search() {
-  int n = adj.size();
-  vector<bool> visited(n, false);
+void graph::depth_first_search()
+{
+    int n = adj.size();
+    vector<bool> visited(n, false);
 
-  for (int i = 0 ; i < n ; i++) {
-    if (!visited[i]) {
-      explore(i, visited);
-      connected_components++;
+    for (int i = 0; i < n; i++)
+    {
+        if (!visited[i])
+        {
+            explore(i, visited);
+            connected_components++;
+        }
     }
-  }
 }
 
-void graph::explore(int u, vector<bool> &visited) {
-  visited[u] = true;
-  for (auto v : adj[u]) {
-    if (!visited[v]) {
-      explore(v, visited);
+void graph::explore(int u, vector<bool> &visited)
+{
+    visited[u] = true;
+    for (auto v : adj[u])
+    {
+        if (!visited[v])
+        {
+            explore(v, visited);
+        }
     }
-  }
 }
 
-int main() {
-  graph g(4);
-  g.addEdge(1, 2);
-  g.addEdge(3, 2);
-  std::cout << g.getConnectedComponents();
-  return 0;
+int main()
+{
+    graph g(4);
+    g.addEdge(1, 2);
+    g.addEdge(3, 2);
+    std::cout << g.getConnectedComponents();
+    return 0;
 }
diff --git a/graph/connected_components_with_dsu.cpp b/graph/connected_components_with_dsu.cpp
index 2c5c6dab5..07fda5d27 100644
--- a/graph/connected_components_with_dsu.cpp
+++ b/graph/connected_components_with_dsu.cpp
@@ -1,27 +1,32 @@
 #include <iostream>
-#include <vector>
 #include <set>
+#include <vector>
 
 int N;  // denotes number of nodes;
 std::vector<int> parent;
 std::vector<int> siz;
-void make_set() {  // function the initialize every node as it's own parent
-    for (int i = 1; i <= N; i++) {
+void make_set()
+{  // function the initialize every node as it's own parent
+    for (int i = 1; i <= N; i++)
+    {
         parent[i] = i;
         siz[i] = 1;
     }
 }
 // To find the component where following node belongs to
-int find_set(int v) {
+int find_set(int v)
+{
     if (v == parent[v])
         return v;
     return parent[v] = find_set(parent[v]);
 }
 
-void union_sets(int a, int b) {  // To join 2 components to belong to one
+void union_sets(int a, int b)
+{  // To join 2 components to belong to one
     a = find_set(a);
     b = find_set(b);
-    if (a != b) {
+    if (a != b)
+    {
         if (siz[a] < siz[b])
             std::swap(a, b);
         parent[b] = a;
@@ -29,23 +34,25 @@ void union_sets(int a, int b) {  // To join 2 components to belong to one
     }
 }
 
-int no_of_connected_components() {  // To find total no of connected components
+int no_of_connected_components()
+{                        // To find total no of connected components
     std::set<int> temp;  // temp set to count number of connected components
-    for (int i = 1; i <= N; i++)
-        temp.insert(find_set(i));
+    for (int i = 1; i <= N; i++) temp.insert(find_set(i));
     return temp.size();
 }
 
 // All critical/corner cases have been taken care of.
 // Input your required values: (not hardcoded)
-int main() {
+int main()
+{
     std::cin >> N;
     parent.resize(N + 1);
     siz.resize(N + 1);
     make_set();
     int edges;
     std::cin >> edges;  // no of edges in the graph
-    while (edges--) {
+    while (edges--)
+    {
         int node_a, node_b;
         std::cin >> node_a >> node_b;
         union_sets(node_a, node_b);
diff --git a/graph/dfs.cpp b/graph/dfs.cpp
index 656711ac8..7c7ec7761 100644
--- a/graph/dfs.cpp
+++ b/graph/dfs.cpp
@@ -3,29 +3,29 @@ using namespace std;
 int v = 4;
 void DFSUtil_(int graph[4][4], bool visited[], int s)
 {
-	visited[s] = true;
-	cout << s << " ";
-	for (int i = 0; i < v; i++)
-	{
-		if (graph[s][i] == 1 && visited[i] == false)
-		{
-			DFSUtil_(graph, visited, i);
-		}
-	}
+    visited[s] = true;
+    cout << s << " ";
+    for (int i = 0; i < v; i++)
+    {
+        if (graph[s][i] == 1 && visited[i] == false)
+        {
+            DFSUtil_(graph, visited, i);
+        }
+    }
 }
 
 void DFS_(int graph[4][4], int s)
 {
-	bool visited[v];
-	memset(visited, 0, sizeof(visited));
-	DFSUtil_(graph, visited, s);
+    bool visited[v];
+    memset(visited, 0, sizeof(visited));
+    DFSUtil_(graph, visited, s);
 }
 
 int main()
 {
-	int graph[4][4] = {{0, 1, 1, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}, {0, 0, 0, 1}};
-	cout << "DFS: ";
-	DFS_(graph, 2);
-	cout << endl;
-	return 0;
+    int graph[4][4] = {{0, 1, 1, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}, {0, 0, 0, 1}};
+    cout << "DFS: ";
+    DFS_(graph, 2);
+    cout << endl;
+    return 0;
 }
\ No newline at end of file
diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index b3ee44c41..f25510935 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -1,14 +1,16 @@
-#include <queue>
-#include <vector>
 #include <cstdio>
 #include <iostream>
+#include <queue>
+#include <vector>
 using namespace std;
 #define INF 10000010
 vector<pair<int, int>> graph[5 * 100001];
 int dis[5 * 100001];
 int dij(vector<pair<int, int>> *v, int s, int *dis)
 {
-    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
+    priority_queue<pair<int, int>, vector<pair<int, int>>,
+                   greater<pair<int, int>>>
+        pq;
     // source distance to zero.
     pq.push(make_pair(0, s));
     dis[s] = 0;
@@ -17,7 +19,8 @@ int dij(vector<pair<int, int>> *v, int s, int *dis)
     {
         u = (pq.top()).second;
         pq.pop();
-        for (vector<pair<int, int>>::iterator it = v[u].begin(); it != v[u].end(); it++)
+        for (vector<pair<int, int>>::iterator it = v[u].begin();
+             it != v[u].end(); it++)
         {
             if (dis[u] + it->first < dis[it->second])
             {
@@ -37,13 +40,13 @@ int main()
         // input edges.
         scanf("%d%d%d", &x, &y, &l);
         graph[x].push_back(make_pair(l, y));
-        graph[y].push_back(make_pair(l, x)); // comment this line for directed graph
+        graph[y].push_back(
+            make_pair(l, x));  // comment this line for directed graph
     }
     // start node.
     scanf("%d", &s);
     // intialise all distances to infinity.
-    for (int i = 1; i <= n; i++)
-        dis[i] = INF;
+    for (int i = 1; i <= n; i++) dis[i] = INF;
     dij(graph, s, dis);
 
     for (int i = 1; i <= n; i++)
diff --git a/graph/kosaraju.cpp b/graph/kosaraju.cpp
index 2e66f131f..0efa291bc 100644
--- a/graph/kosaraju.cpp
+++ b/graph/kosaraju.cpp
@@ -1,134 +1,135 @@
-/* Implementation of Kosaraju's Algorithm to find out the strongly connected components (SCCs) in a graph. 
-   Author:Anirban166
-*/   
+/* Implementation of Kosaraju's Algorithm to find out the strongly connected
+   components (SCCs) in a graph. Author:Anirban166
+*/
 
-#include<iostream>
-#include<vector>
+#include <iostream>
+#include <vector>
 
 using namespace std;
 
 /**
-* Iterative function/method to print graph:
-* @param a[] : array of vectors (2D)
-* @param V : vertices
-* @return void 
-**/
-void print(vector<int> a[],int V)
+ * Iterative function/method to print graph:
+ * @param a[] : array of vectors (2D)
+ * @param V : vertices
+ * @return void
+ **/
+void print(vector<int> a[], int V)
 {
-    for(int i=0;i<V;i++)
+    for (int i = 0; i < V; i++)
     {
-        if(!a[i].empty())
-            cout<<"i="<<i<<"-->";
-        for(int j=0;j<a[i].size();j++)
-            cout<<a[i][j]<<" ";
-        if(!a[i].empty())
-            cout<<endl;
+        if (!a[i].empty())
+            cout << "i=" << i << "-->";
+        for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
+        if (!a[i].empty())
+            cout << endl;
     }
 }
 
 /**
-* //Recursive function/method to push vertices into stack passed as parameter:
-* @param v : vertices
-* @param &st : stack passed by reference
-* @param vis[] : array to keep track of visited nodes (boolean type)
-* @param adj[] : array of vectors to represent graph
-* @return void 
-**/
-void push_vertex(int v,stack<int> &st,bool vis[],vector<int> adj[])
+ * //Recursive function/method to push vertices into stack passed as parameter:
+ * @param v : vertices
+ * @param &st : stack passed by reference
+ * @param vis[] : array to keep track of visited nodes (boolean type)
+ * @param adj[] : array of vectors to represent graph
+ * @return void
+ **/
+void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[])
 {
-    vis[v]=true;
-    for(auto i=adj[v].begin();i!=adj[v].end();i++)
+    vis[v] = true;
+    for (auto i = adj[v].begin(); i != adj[v].end(); i++)
     {
-        if(vis[*i]==false)
-            push_vertex(*i,st,vis,adj);
+        if (vis[*i] == false)
+            push_vertex(*i, st, vis, adj);
     }
     st.push(v);
 }
 
-
 /**
-* //Recursive function/method to implement depth first traversal(dfs):
-* @param v : vertices
-* @param vis[] : array to keep track of visited nodes (boolean type)
-* @param grev[] : graph with reversed edges
-* @return void 
-**/
-void dfs(int v,bool vis[],vector<int> grev[])
+ * //Recursive function/method to implement depth first traversal(dfs):
+ * @param v : vertices
+ * @param vis[] : array to keep track of visited nodes (boolean type)
+ * @param grev[] : graph with reversed edges
+ * @return void
+ **/
+void dfs(int v, bool vis[], vector<int> grev[])
 {
-    vis[v]=true;
+    vis[v] = true;
     // cout<<v<<" ";
-    for(auto i=grev[v].begin();i!=grev[v].end();i++)
+    for (auto i = grev[v].begin(); i != grev[v].end(); i++)
     {
-        if(vis[*i]==false)
-            dfs(*i,vis,grev);
+        if (vis[*i] == false)
+            dfs(*i, vis, grev);
     }
 }
 
-//function/method to implement Kosaraju's Algorithm:
+// function/method to implement Kosaraju's Algorithm:
 /**
 * Info about the method
 * @param V : vertices in graph
 * @param adj[] : array of vectors that represent a graph (adjacency list/array)
-* @return int ( 0, 1, 2..and so on, only unsigned values as either there can be no SCCs i.e. none(0) or there will be x no. of SCCs (x>0))
-   i.e. it returns the count of (number of) strongly connected components (SCCs) in the graph. (variable 'count_scc' within function)
+* @return int ( 0, 1, 2..and so on, only unsigned values as either there can be
+no SCCs i.e. none(0) or there will be x no. of SCCs (x>0)) i.e. it returns the
+count of (number of) strongly connected components (SCCs) in the graph.
+(variable 'count_scc' within function)
 **/
 int kosaraju(int V, vector<int> adj[])
 {
-    bool vis[V]={};
+    bool vis[V] = {};
     stack<int> st;
-    for(int v=0;v<V;v++)
+    for (int v = 0; v < V; v++)
     {
-        if(vis[v]==false)
-            push_vertex(v,st,vis,adj);
+        if (vis[v] == false)
+            push_vertex(v, st, vis, adj);
     }
-    //making new graph (grev) with reverse edges as in adj[]:
+    // making new graph (grev) with reverse edges as in adj[]:
     vector<int> grev[V];
-    for(int i=0;i<V+1;i++)
+    for (int i = 0; i < V + 1; i++)
     {
-        for(auto j=adj[i].begin();j!=adj[i].end();j++)
+        for (auto j = adj[i].begin(); j != adj[i].end(); j++)
         {
             grev[*j].push_back(i);
         }
     }
     // cout<<"grev="<<endl; ->debug statement
     // print(grev,V);       ->debug statement
-    //reinitialise visited to 0
-    for(int i=0;i<V;i++)
-        vis[i]=false;
-    int count_scc=0;
-    while(!st.empty())
+    // reinitialise visited to 0
+    for (int i = 0; i < V; i++) vis[i] = false;
+    int count_scc = 0;
+    while (!st.empty())
     {
-        int t=st.top();
+        int t = st.top();
         st.pop();
-        if(vis[t]==false)
+        if (vis[t] == false)
         {
-            dfs(t,vis,grev);
+            dfs(t, vis, grev);
             count_scc++;
         }
     }
-    // cout<<"count_scc="<<count_scc<<endl; //in case you want to print here itself, uncomment & change return type of function to void.
+    // cout<<"count_scc="<<count_scc<<endl; //in case you want to print here
+    // itself, uncomment & change return type of function to void.
     return count_scc;
 }
 
-//All critical/corner cases have been taken care of.
-//Input your required values: (not hardcoded)
+// All critical/corner cases have been taken care of.
+// Input your required values: (not hardcoded)
 int main()
 {
     int t;
-    cin>>t; 
-    while(t--)
+    cin >> t;
+    while (t--)
     {
-        int a,b ; //a->number of nodes, b->directed edges.
-   	  cin>>a>>b;
-   	  int m,n;
-   	  vector<int> adj[a+1];
-        for(int i=0;i<b;i++) //take total b inputs of 2 vertices each required to form an edge.
+        int a, b;  // a->number of nodes, b->directed edges.
+        cin >> a >> b;
+        int m, n;
+        vector<int> adj[a + 1];
+        for (int i = 0; i < b; i++)  // take total b inputs of 2 vertices each
+                                     // required to form an edge.
         {
-            cin>>m>>n; //take input m,n denoting edge from m->n.
+            cin >> m >> n;  // take input m,n denoting edge from m->n.
             adj[m].push_back(n);
         }
-        //pass number of nodes and adjacency array as parameters to function:
-        cout<<kosaraju(a, adj)<<endl;
+        // pass number of nodes and adjacency array as parameters to function:
+        cout << kosaraju(a, adj) << endl;
     }
     return 0;
 }
diff --git a/graph/kruskal.cpp b/graph/kruskal.cpp
index 21b04ce49..6bffd5cd9 100644
--- a/graph/kruskal.cpp
+++ b/graph/kruskal.cpp
@@ -1,6 +1,6 @@
 #include <iostream>
 //#include <boost/multiprecision/cpp_int.hpp>
-//using namespace boost::multiprecision;
+// using namespace boost::multiprecision;
 const int mx = 1e6 + 5;
 const long int inf = 2e9;
 typedef long long ll;
@@ -20,116 +20,114 @@ typedef long long ll;
 #define ub upper_bound
 #define endl "\n"
 #define fast                          \
-	ios_base::sync_with_stdio(false); \
-	cin.tie(NULL);                    \
-	cout.tie(NULL);
+    ios_base::sync_with_stdio(false); \
+    cin.tie(NULL);                    \
+    cout.tie(NULL);
 using namespace std;
 void in(int &x)
 {
-	register int c = gc();
-	x = 0;
-	int neg = 0;
-	for (; ((c < 48 || c > 57) && c != '-'); c = gc())
-		;
-	if (c == '-')
-	{
-		neg = 1;
-		c = gc();
-	}
-	for (; c > 47 && c < 58; c = gc())
-	{
-		x = (x << 1) + (x << 3) + c - 48;
-	}
-	if (neg)
-		x = -x;
+    register int c = gc();
+    x = 0;
+    int neg = 0;
+    for (; ((c < 48 || c > 57) && c != '-'); c = gc())
+        ;
+    if (c == '-')
+    {
+        neg = 1;
+        c = gc();
+    }
+    for (; c > 47 && c < 58; c = gc())
+    {
+        x = (x << 1) + (x << 3) + c - 48;
+    }
+    if (neg)
+        x = -x;
 }
 void out(int n)
 {
-	int N = n, rev, count = 0;
-	rev = N;
-	if (N == 0)
-	{
-		pc('0');
-		return;
-	}
-	while ((rev % 10) == 0)
-	{
-		count++;
-		rev /= 10;
-	}
-	rev = 0;
-	while (N != 0)
-	{
-		rev = (rev << 3) + (rev << 1) + N % 10;
-		N /= 10;
-	}
-	while (rev != 0)
-	{
-		pc(rev % 10 + '0');
-		rev /= 10;
-	}
-	while (count--)
-		pc('0');
+    int N = n, rev, count = 0;
+    rev = N;
+    if (N == 0)
+    {
+        pc('0');
+        return;
+    }
+    while ((rev % 10) == 0)
+    {
+        count++;
+        rev /= 10;
+    }
+    rev = 0;
+    while (N != 0)
+    {
+        rev = (rev << 3) + (rev << 1) + N % 10;
+        N /= 10;
+    }
+    while (rev != 0)
+    {
+        pc(rev % 10 + '0');
+        rev /= 10;
+    }
+    while (count--) pc('0');
 }
 ll parent[mx], arr[mx], node, edge;
 vector<pair<ll, pair<ll, ll>>> v;
 void initial()
 {
-	int i;
-	rep(i, node + edge)
-		parent[i] = i;
+    int i;
+    rep(i, node + edge) parent[i] = i;
 }
 int root(int i)
 {
-	while (parent[i] != i)
-	{
-		parent[i] = parent[parent[i]];
-		i = parent[i];
-	}
-	return i;
+    while (parent[i] != i)
+    {
+        parent[i] = parent[parent[i]];
+        i = parent[i];
+    }
+    return i;
 }
 void join(int x, int y)
 {
-	int root_x = root(x); //Disjoint set union by rank
-	int root_y = root(y);
-	parent[root_x] = root_y;
+    int root_x = root(x);  // Disjoint set union by rank
+    int root_y = root(y);
+    parent[root_x] = root_y;
 }
 ll kruskal()
 {
-	ll mincost = 0, i, x, y;
-	rep(i, edge)
-	{
-		x = v[i].second.first;
-		y = v[i].second.second;
-		if (root(x) != root(y))
-		{
-			mincost += v[i].first;
-			join(x, y);
-		}
-	}
-	return mincost;
+    ll mincost = 0, i, x, y;
+    rep(i, edge)
+    {
+        x = v[i].second.first;
+        y = v[i].second.second;
+        if (root(x) != root(y))
+        {
+            mincost += v[i].first;
+            join(x, y);
+        }
+    }
+    return mincost;
 }
 int main()
 {
-	fast;
-	while (1)
-	{
-		int i, j, from, to, cost, totalcost = 0;
-		cin >> node >> edge; //Enter the nodes and edges
-		if (node == 0 && edge == 0)
-			break; //Enter 0 0 to break out
-		initial(); //Initialise the parent array
-		rep(i, edge)
-		{
-			cin >> from >> to >> cost;
-			v.pb(mp(cost, mp(from, to)));
-			totalcost += cost;
-		}
-		sort(v.begin(), v.end());
-		// rep(i,v.size())
-		// 	cout<<v[i].first<<"  ";
-		cout << kruskal() << endl;
-		v.clear();
-	}
-	return 0;
+    fast;
+    while (1)
+    {
+        int i, j, from, to, cost, totalcost = 0;
+        cin >> node >> edge;  // Enter the nodes and edges
+        if (node == 0 && edge == 0)
+            break;  // Enter 0 0 to break out
+        initial();  // Initialise the parent array
+        rep(i, edge)
+        {
+            cin >> from >> to >> cost;
+            v.pb(mp(cost, mp(from, to)));
+            totalcost += cost;
+        }
+        sort(v.begin(), v.end());
+        // rep(i,v.size())
+        // 	cout<<v[i].first<<"  ";
+        cout << kruskal() << endl;
+        v.clear();
+    }
+    return 0;
 }
diff --git a/graph/lca.cpp b/graph/lca.cpp
index 9c7be456e..743fb31ed 100644
--- a/graph/lca.cpp
+++ b/graph/lca.cpp
@@ -10,16 +10,16 @@ const int LG = log2(N) + 1;
 struct lca
 {
     int n;
-    vector<int> adj[N]; // Graph
-    int up[LG][N]; // build this table
-    int level[N]; // get the levels of all of them
+    vector<int> adj[N];  // Graph
+    int up[LG][N];       // build this table
+    int level[N];        // get the levels of all of them
 
-    lca(int n_): n(n_)
+    lca(int n_) : n(n_)
     {
         memset(up, -1, sizeof(up));
         memset(level, 0, sizeof(level));
         for (int i = 0; i < n - 1; ++i)
-	{
+        {
             int a, b;
             cin >> a >> b;
             a--;
@@ -34,15 +34,15 @@ struct lca
     void verify()
     {
         for (int i = 0; i < n; ++i)
-	{
+        {
             cout << i << " : level: " << level[i] << endl;
         }
         cout << endl;
         for (int i = 0; i < LG; ++i)
-	{
+        {
             cout << "Power:" << i << ": ";
             for (int j = 0; j < n; ++j)
-	    {
+            {
                 cout << up[i][j] << " ";
             }
             cout << endl;
@@ -52,11 +52,11 @@ struct lca
     void build()
     {
         for (int i = 1; i < LG; ++i)
-	{
+        {
             for (int j = 0; j < n; ++j)
-	    {
+            {
                 if (up[i - 1][j] != -1)
-		{
+                {
                     up[i][j] = up[i - 1][up[i - 1][j]];
                 }
             }
@@ -66,10 +66,10 @@ struct lca
     void dfs(int node, int par)
     {
         up[0][node] = par;
-        for (auto i: adj[node])
-	{
+        for (auto i : adj[node])
+        {
             if (i != par)
-	    {
+            {
                 level[i] = level[node] + 1;
                 dfs(i, node);
             }
@@ -80,28 +80,28 @@ struct lca
         u--;
         v--;
         if (level[v] > level[u])
-	{
+        {
             swap(u, v);
         }
         // u is at the bottom.
         int dist = level[u] - level[v];
         // Go up this much distance
         for (int i = LG - 1; i >= 0; --i)
-	{
+        {
             if (dist & (1 << i))
-	    {
+            {
                 u = up[i][u];
             }
         }
         if (u == v)
-	{
+        {
             return u;
         }
         assert(level[u] == level[v]);
         for (int i = LG - 1; i >= 0; --i)
-	{
+        {
             if (up[i][u] != up[i][v])
-	    {
+            {
                 u = up[i][u];
                 v = up[i][v];
             }
@@ -113,8 +113,8 @@ struct lca
 
 int main()
 {
-    int n; // number of nodes in the tree.
-    lca l(n); // will take the input in the format given
+    int n;     // number of nodes in the tree.
+    lca l(n);  // will take the input in the format given
     // n-1 edges of the form
     // a b
     // Use verify function to see.
diff --git a/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp b/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
index ee394d9f0..f02a48e01 100644
--- a/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
+++ b/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
@@ -4,41 +4,47 @@
  * Copyright: 2020, Open-Source
  * Last Modified: May 25, 2020
  */
-#include <iostream>
-#include <queue>
-#include <tuple>
 #include <algorithm>
 #include <bitset>
-#include <limits>
 #include <cstring>
-#include <vector>
+#include <iostream>
+#include <limits>
+#include <queue>
+#include <tuple>
 #include <utility>
+#include <vector>
 // std::max capacity of node in graph
 const int MAXN = 505;
-class Graph {
+class Graph
+{
     int residual_capacity[MAXN][MAXN];
     int capacity[MAXN][MAXN];  //  used while checking the flow of edge
     int total_nodes;
     int total_edges, source, sink;
     int parent[MAXN];
-    std::vector <std::tuple <int, int, int> >edge_participated;
-    std::bitset <MAXN> visited;
+    std::vector<std::tuple<int, int, int> > edge_participated;
+    std::bitset<MAXN> visited;
     int max_flow = 0;
-    bool bfs(int source, int sink) {  //  to find the augmented - path
+    bool bfs(int source, int sink)
+    {  //  to find the augmented - path
         memset(parent, -1, sizeof(parent));
         visited.reset();
-        std::queue<int>q;
+        std::queue<int> q;
         q.push(source);
         bool is_path_found = false;
-        while (q.empty() == false && is_path_found == false) {
+        while (q.empty() == false && is_path_found == false)
+        {
             int current_node = q.front();
             visited.set(current_node);
             q.pop();
-            for (int i = 0; i < total_nodes; ++i) {
-                if (residual_capacity[current_node][i] > 0 && !visited[i]) {
+            for (int i = 0; i < total_nodes; ++i)
+            {
+                if (residual_capacity[current_node][i] > 0 && !visited[i])
+                {
                     visited.set(i);
                     parent[i] = current_node;
-                    if (i == sink) {
+                    if (i == sink)
+                    {
                         return true;
                     }
                     q.push(i);
@@ -49,29 +55,33 @@ class Graph {
     }
 
  public:
-    Graph() {
-        memset(residual_capacity, 0, sizeof(residual_capacity));
-    }
-    void set_graph(void) {
+    Graph() { memset(residual_capacity, 0, sizeof(residual_capacity)); }
+    void set_graph(void)
+    {
         std::cin >> total_nodes >> total_edges >> source >> sink;
-        for (int start, destination, capacity_, i = 0; i < total_edges; ++i) {
+        for (int start, destination, capacity_, i = 0; i < total_edges; ++i)
+        {
             std::cin >> start >> destination >> capacity_;
             residual_capacity[start][destination] = capacity_;
             capacity[start][destination] = capacity_;
         }
     }
-    void ford_fulkerson(void) {
-        while (bfs(source, sink)) {
+    void ford_fulkerson(void)
+    {
+        while (bfs(source, sink))
+        {
             int current_node = sink;
             int flow = std::numeric_limits<int>::max();
-            while (current_node != source) {
+            while (current_node != source)
+            {
                 int parent_ = parent[current_node];
                 flow = std::min(flow, residual_capacity[parent_][current_node]);
                 current_node = parent_;
             }
             current_node = sink;
             max_flow += flow;
-            while ( current_node != source ) {
+            while (current_node != source)
+            {
                 int parent_ = parent[current_node];
                 residual_capacity[parent_][current_node] -= flow;
                 residual_capacity[current_node][parent_] += flow;
@@ -79,31 +89,34 @@ class Graph {
             }
         }
     }
-    void print_flow_info(void) {
-        for (int i = 0; i < total_nodes; ++i) {
-            for (int j = 0; j < total_nodes; ++j) {
-                if (capacity[i][j] &&
-                        residual_capacity[i][j] < capacity[i][j]) {
-                    edge_participated.push_back(
-                            std::make_tuple(i, j,
-                                capacity[i][j]-residual_capacity[i][j]));
+    void print_flow_info(void)
+    {
+        for (int i = 0; i < total_nodes; ++i)
+        {
+            for (int j = 0; j < total_nodes; ++j)
+            {
+                if (capacity[i][j] && residual_capacity[i][j] < capacity[i][j])
+                {
+                    edge_participated.push_back(std::make_tuple(
+                        i, j, capacity[i][j] - residual_capacity[i][j]));
                 }
             }
         }
-        std::cout << "\nNodes : " << total_nodes
-            << "\nMax flow: " << max_flow
-            << "\nEdge present in flow: " << edge_participated.size()
-            << '\n';
-        std::cout<< "\nSource\tDestination\tCapacity\total_nodes";
-        for (auto&edge_data : edge_participated) {
+        std::cout << "\nNodes : " << total_nodes << "\nMax flow: " << max_flow
+                  << "\nEdge present in flow: " << edge_participated.size()
+                  << '\n';
+        std::cout << "\nSource\tDestination\tCapacity\total_nodes";
+        for (auto& edge_data : edge_participated)
+        {
             int source, destination, capacity_;
             std::tie(source, destination, capacity_) = edge_data;
-            std::cout << source << "\t" << destination << "\t\t"
-                      << capacity_ <<'\t';
+            std::cout << source << "\t" << destination << "\t\t" << capacity_
+                      << '\t';
         }
     }
 };
-int main(void) {
+int main(void)
+{
     /*
        Input Graph: (for testing )
         4 5 0 3
@@ -119,4 +132,3 @@ int main(void) {
     graph.print_flow_info();
     return 0;
 }
-
diff --git a/graph/prim.cpp b/graph/prim.cpp
index 2923b5b25..8332bdb36 100644
--- a/graph/prim.cpp
+++ b/graph/prim.cpp
@@ -1,23 +1,25 @@
 // C++ program to implement Prim's Algorithm
 #include <iostream>
-#include <vector>
 #include <queue>
+#include <vector>
 
 const int MAX = 1e4 + 5;
-typedef std:: pair<int, int> PII;
+typedef std::pair<int, int> PII;
 
 bool marked[MAX];
-std:: vector <PII> adj[MAX];
+std::vector<PII> adj[MAX];
 
-int prim(int x) {
+int prim(int x)
+{
     // priority queue to maintain edges with respect to weights
-    std:: priority_queue<PII, std:: vector<PII>, std:: greater<PII> > Q;
+    std::priority_queue<PII, std::vector<PII>, std::greater<PII> > Q;
     int y;
     int minimumCost = 0;
     PII p;
 
-    Q.push(std:: make_pair(0, x));
-    while (!Q.empty()) {
+    Q.push(std::make_pair(0, x));
+    while (!Q.empty())
+    {
         // Select the edge with minimum weight
         p = Q.top();
         Q.pop();
@@ -27,7 +29,8 @@ int prim(int x) {
             continue;
         minimumCost += p.first;
         marked[x] = true;
-        for (int i = 0; i < adj[x].size(); ++i) {
+        for (int i = 0; i < adj[x].size(); ++i)
+        {
             y = adj[x][i].second;
             if (marked[y] == false)
                 Q.push(adj[x][i]);
@@ -36,23 +39,25 @@ int prim(int x) {
     return minimumCost;
 }
 
-int main() {
+int main()
+{
     int nodes, edges, x, y;
     int weight, minimumCost;
 
-    std:: cin >> nodes >> edges;  // number of nodes & edges in graph
+    std::cin >> nodes >> edges;  // number of nodes & edges in graph
     if (nodes == 0 || edges == 0)
         return 0;
 
     // Edges with their nodes & weight
-    for (int i = 0; i < edges; ++i) {
+    for (int i = 0; i < edges; ++i)
+    {
         std::cin >> x >> y >> weight;
-        adj[x].push_back(std:: make_pair(weight, y));
-        adj[y].push_back(std:: make_pair(weight, x));
+        adj[x].push_back(std::make_pair(weight, y));
+        adj[y].push_back(std::make_pair(weight, x));
     }
 
     // Selecting 1 as the starting node
     minimumCost = prim(1);
-    std:: cout << minimumCost << std:: endl;
+    std::cout << minimumCost << std::endl;
     return 0;
 }
diff --git a/graph/topological_sort.cpp b/graph/topological_sort.cpp
index 2203231ae..d863c6993 100644
--- a/graph/topological_sort.cpp
+++ b/graph/topological_sort.cpp
@@ -1,53 +1,54 @@
+#include <algorithm>
 #include <iostream>
 #include <vector>
-#include <algorithm>
 using namespace std;
 
-int n, m; // For number of Vertices (V) and number of edges (E)
+int n, m;  // For number of Vertices (V) and number of edges (E)
 vector<vector<int>> G;
 vector<bool> visited;
 vector<int> ans;
 
 void dfs(int v)
 {
-  visited[v] = true;
-  for (int u : G[v])
-  {
-    if (!visited[u])
-      dfs(u);
-  }
-  ans.push_back(v);
+    visited[v] = true;
+    for (int u : G[v])
+    {
+        if (!visited[u])
+            dfs(u);
+    }
+    ans.push_back(v);
 }
 
 void topological_sort()
 {
-  visited.assign(n, false);
-  ans.clear();
-  for (int i = 0; i < n; ++i)
-  {
-    if (!visited[i])
-      dfs(i);
-  }
-  reverse(ans.begin(), ans.end());
+    visited.assign(n, false);
+    ans.clear();
+    for (int i = 0; i < n; ++i)
+    {
+        if (!visited[i])
+            dfs(i);
+    }
+    reverse(ans.begin(), ans.end());
 }
 int main()
 {
-  cout << "Enter the number of vertices and the number of directed edges\n";
-  cin >> n >> m;
-  int x, y;
-  G.resize(n, vector<int>());
-  for (int i = 0; i < n; ++i)
-  {
-    cin >> x >> y;
-    x--, y--; // to convert 1-indexed to 0-indexed
-    G[x].push_back(y);
-  }
-  topological_sort();
-  cout << "Topological Order : \n";
-  for (int v : ans)
-  {
-    cout << v + 1 << ' '; // converting zero based indexing back to one based.
-  }
-  cout << '\n';
-  return 0;
+    cout << "Enter the number of vertices and the number of directed edges\n";
+    cin >> n >> m;
+    int x, y;
+    G.resize(n, vector<int>());
+    for (int i = 0; i < n; ++i)
+    {
+        cin >> x >> y;
+        x--, y--;  // to convert 1-indexed to 0-indexed
+        G[x].push_back(y);
+    }
+    topological_sort();
+    cout << "Topological Order : \n";
+    for (int v : ans)
+    {
+        cout << v + 1
+             << ' ';  // converting zero based indexing back to one based.
+    }
+    cout << '\n';
+    return 0;
 }
diff --git a/graph/topological_sort_by_kahns_algo.cpp b/graph/topological_sort_by_kahns_algo.cpp
index eda2a74bc..b56ae5651 100644
--- a/graph/topological_sort_by_kahns_algo.cpp
+++ b/graph/topological_sort_by_kahns_algo.cpp
@@ -1,63 +1,75 @@
 #include <stdio.h>
 #include <string.h>
 #include <iostream>
-#include <vector>
 #include <queue>
+#include <vector>
 
 int *topoSortKahn(int N, std::vector<int> adj[]);
 
-int main() {
+int main()
+{
     int nodes, edges;
     std::cin >> edges >> nodes;
     if (edges == 0 || nodes == 0)
         return 0;
     int u, v;
 
-    std::vector<int>graph[nodes];
+    std::vector<int> graph[nodes];
     // create graph
     // example
     // 6 6
     // 5 0 5 2 2 3 4 0 4 1 1 3
 
-    for (int i = 0; i < edges; i++) {
+    for (int i = 0; i < edges; i++)
+    {
         std::cin >> u >> v;
         graph[u].push_back(v);
     }
 
     int *topo = topoSortKahn(nodes, graph);
     // topologically sorted nodes
-    for (int i = 0; i < nodes; i++) {
+    for (int i = 0; i < nodes; i++)
+    {
         std::cout << topo[i] << " ";
     }
 }
 
-int* topoSortKahn(int V, std::vector<int> adj[]) {
-    std::vector<bool>vis(V+1, false);
-    std::vector<int>deg(V+1, 0);
-    for (int i = 0; i < V; i++) {
-        for (int j = 0; j < adj[i].size(); j++) {
+int *topoSortKahn(int V, std::vector<int> adj[])
+{
+    std::vector<bool> vis(V + 1, false);
+    std::vector<int> deg(V + 1, 0);
+    for (int i = 0; i < V; i++)
+    {
+        for (int j = 0; j < adj[i].size(); j++)
+        {
             deg[adj[i][j]]++;
         }
     }
-    std::queue<int>q;
-    for (int i = 0; i < V; i++) {
-        if (deg[i] == 0) {
+    std::queue<int> q;
+    for (int i = 0; i < V; i++)
+    {
+        if (deg[i] == 0)
+        {
             q.push(i);
             vis[i] = true;
         }
     }
-    int *arr = new int[V+1];
-    memset(arr, 0, V+1);
+    int *arr = new int[V + 1];
+    memset(arr, 0, V + 1);
     int count = 0;
-    while (!q.empty()) {
+    while (!q.empty())
+    {
         int cur = q.front();
         q.pop();
         arr[count] = cur;
         count++;
-        for (int i = 0; i < adj[cur].size(); i++) {
-            if (!vis[adj[cur][i]]) {
+        for (int i = 0; i < adj[cur].size(); i++)
+        {
+            if (!vis[adj[cur][i]])
+            {
                 deg[adj[cur][i]]--;
-                if (deg[adj[cur][i]] == 0) {
+                if (deg[adj[cur][i]] == 0)
+                {
                     q.push(adj[cur][i]);
                     vis[adj[cur][i]] = true;
                 }
diff --git a/greedy_algorithms/dijkstra.cpp b/greedy_algorithms/dijkstra.cpp
index 0c7fffc8c..b87b4ab10 100644
--- a/greedy_algorithms/dijkstra.cpp
+++ b/greedy_algorithms/dijkstra.cpp
@@ -1,19 +1,18 @@
-#include <iostream>
 #include <limits.h>
+#include <iostream>
 
 using namespace std;
 
-//Wrapper class for storing a graph
+// Wrapper class for storing a graph
 class Graph
 {
-public:
+ public:
     int vertexNum;
     int **edges;
 
-    //Constructs a graph with V vertices and E edges
+    // Constructs a graph with V vertices and E edges
     Graph(const int V)
     {
-
         // initializes the array edges.
         this->edges = new int *[V];
         for (int i = 0; i < V; i++)
@@ -33,13 +32,13 @@ public:
         this->vertexNum = V;
     }
 
-    //Adds the given edge to the graph
+    // Adds the given edge to the graph
     void addEdge(int src, int dst, int weight)
     {
         this->edges[src][dst] = weight;
     }
 };
-//Utility function to find minimum distance vertex in mdist
+// Utility function to find minimum distance vertex in mdist
 int minDistance(int mdist[], bool vset[], int V)
 {
     int minVal = INT_MAX, minInd = 0;
@@ -55,7 +54,7 @@ int minDistance(int mdist[], bool vset[], int V)
     return minInd;
 }
 
-//Utility function to print distances
+// Utility function to print distances
 void print(int dist[], int V)
 {
     cout << "\nVertex  Distance" << endl;
@@ -68,17 +67,17 @@ void print(int dist[], int V)
     }
 }
 
-//The main function that finds the shortest path from given source
-//to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
-//weights
+// The main function that finds the shortest path from given source
+// to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
+// weights
 void Dijkstra(Graph graph, int src)
 {
     int V = graph.vertexNum;
-    int mdist[V]; //Stores updated distances to vertex
-    bool vset[V]; // vset[i] is true if the vertex i included
+    int mdist[V];  // Stores updated distances to vertex
+    bool vset[V];  // vset[i] is true if the vertex i included
     // in the shortest path tree
 
-    //Initialise mdist and vset. Set distance of source as zero
+    // Initialise mdist and vset. Set distance of source as zero
     for (int i = 0; i < V; i++)
     {
         mdist[i] = INT_MAX;
@@ -87,7 +86,7 @@ void Dijkstra(Graph graph, int src)
 
     mdist[src] = 0;
 
-    //iterate to find shortest path
+    // iterate to find shortest path
     for (int count = 0; count < V - 1; count++)
     {
         int u = minDistance(mdist, vset, V);
@@ -96,7 +95,8 @@ void Dijkstra(Graph graph, int src)
 
         for (int v = 0; v < V; v++)
         {
-            if (!vset[v] && graph.edges[u][v] && mdist[u] + graph.edges[u][v] < mdist[v])
+            if (!vset[v] && graph.edges[u][v] &&
+                mdist[u] + graph.edges[u][v] < mdist[v])
             {
                 mdist[v] = mdist[u] + graph.edges[u][v];
             }
@@ -106,7 +106,7 @@ void Dijkstra(Graph graph, int src)
     print(mdist, V);
 }
 
-//Driver Function
+// Driver Function
 int main()
 {
     int V, E, gsrc;
diff --git a/greedy_algorithms/huffman.cpp b/greedy_algorithms/huffman.cpp
index 253d8d0b5..bf3d9ff9a 100644
--- a/greedy_algorithms/huffman.cpp
+++ b/greedy_algorithms/huffman.cpp
@@ -1,109 +1,106 @@
-// C++ program for Huffman Coding 
+// C++ program for Huffman Coding
 #include <iostream>
-#include <queue> 
-using namespace std; 
-  
-// A Huffman tree node 
-struct MinHeapNode { 
-  
-    // One of the input characters 
-    char data; 
-  
-    // Frequency of the character 
-    unsigned freq; 
-  
-    // Left and right child 
-    MinHeapNode *left, *right; 
-  
-    MinHeapNode(char data, unsigned freq) 
-  
-    { 
-  
-        left = right = NULL; 
-        this->data = data; 
-        this->freq = freq; 
-    } 
-}; 
-  
-// For comparison of 
-// two heap nodes (needed in min heap) 
-struct compare { 
-  
-    bool operator()(MinHeapNode* l, MinHeapNode* r) 
-  
-    { 
-        return (l->freq > r->freq); 
-    } 
-}; 
-  
-// Prints huffman codes from 
-// the root of Huffman Tree. 
-void printCodes(struct MinHeapNode* root, string str) 
-{ 
-  
-    if (!root) 
-        return; 
-  
-    if (root->data != '$') 
-        cout << root->data << ": " << str << "\n"; 
-  
-    printCodes(root->left, str + "0"); 
-    printCodes(root->right, str + "1"); 
-} 
-  
-// The main function that builds a Huffman Tree and 
-// print codes by traversing the built Huffman Tree 
-void HuffmanCodes(char data[], int freq[], int size) 
-{ 
-    struct MinHeapNode *left, *right, *top; 
-  
-    // Create a min heap & inserts all characters of data[] 
-    priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap; 
-  
-    for (int i = 0; i < size; ++i) 
-        minHeap.push(new MinHeapNode(data[i], freq[i])); 
-  
-    // Iterate while size of heap doesn't become 1 
-    while (minHeap.size() != 1) { 
-  
-        // Extract the two minimum 
-        // freq items from min heap 
-        left = minHeap.top(); 
-        minHeap.pop(); 
-  
-        right = minHeap.top(); 
-        minHeap.pop(); 
-  
-        // Create a new internal node with 
-        // frequency equal to the sum of the 
-        // two nodes frequencies. Make the 
-        // two extracted node as left and right children 
-        // of this new node. Add this node 
-        // to the min heap '$' is a special value 
-        // for internal nodes, not used 
-        top = new MinHeapNode('$', left->freq + right->freq); 
-  
-        top->left = left; 
-        top->right = right; 
-  
-        minHeap.push(top); 
-    } 
-  
-    // Print Huffman codes using 
-    // the Huffman tree built above 
-    printCodes(minHeap.top(), ""); 
-} 
-  
-// Driver program to test above functions 
-int main() 
-{ 
-  
-    char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; 
-    int freq[] = { 5, 9, 12, 13, 16, 45 }; 
-  
-    int size = sizeof(arr) / sizeof(arr[0]); 
-  
-    HuffmanCodes(arr, freq, size); 
-  
-    return 0; 
-} 
+#include <queue>
+using namespace std;
+
+// A Huffman tree node
+struct MinHeapNode
+{
+    // One of the input characters
+    char data;
+
+    // Frequency of the character
+    unsigned freq;
+
+    // Left and right child
+    MinHeapNode *left, *right;
+
+    MinHeapNode(char data, unsigned freq)
+
+    {
+        left = right = NULL;
+        this->data = data;
+        this->freq = freq;
+    }
+};
+
+// For comparison of
+// two heap nodes (needed in min heap)
+struct compare
+{
+    bool operator()(MinHeapNode* l, MinHeapNode* r)
+
+    {
+        return (l->freq > r->freq);
+    }
+};
+
+// Prints huffman codes from
+// the root of Huffman Tree.
+void printCodes(struct MinHeapNode* root, string str)
+{
+    if (!root)
+        return;
+
+    if (root->data != '$')
+        cout << root->data << ": " << str << "\n";
+
+    printCodes(root->left, str + "0");
+    printCodes(root->right, str + "1");
+}
+
+// The main function that builds a Huffman Tree and
+// print codes by traversing the built Huffman Tree
+void HuffmanCodes(char data[], int freq[], int size)
+{
+    struct MinHeapNode *left, *right, *top;
+
+    // Create a min heap & inserts all characters of data[]
+    priority_queue<MinHeapNode*, vector<MinHeapNode*>, compare> minHeap;
+
+    for (int i = 0; i < size; ++i)
+        minHeap.push(new MinHeapNode(data[i], freq[i]));
+
+    // Iterate while size of heap doesn't become 1
+    while (minHeap.size() != 1)
+    {
+        // Extract the two minimum
+        // freq items from min heap
+        left = minHeap.top();
+        minHeap.pop();
+
+        right = minHeap.top();
+        minHeap.pop();
+
+        // Create a new internal node with
+        // frequency equal to the sum of the
+        // two nodes frequencies. Make the
+        // two extracted node as left and right children
+        // of this new node. Add this node
+        // to the min heap '$' is a special value
+        // for internal nodes, not used
+        top = new MinHeapNode('$', left->freq + right->freq);
+
+        top->left = left;
+        top->right = right;
+
+        minHeap.push(top);
+    }
+
+    // Print Huffman codes using
+    // the Huffman tree built above
+    printCodes(minHeap.top(), "");
+}
+
+// Driver program to test above functions
+int main()
+{
+    char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
+    int freq[] = {5, 9, 12, 13, 16, 45};
+
+    int size = sizeof(arr) / sizeof(arr[0]);
+
+    HuffmanCodes(arr, freq, size);
+
+    return 0;
+}
diff --git a/greedy_algorithms/knapsack.cpp b/greedy_algorithms/knapsack.cpp
index 2135bd1eb..81fd879de 100644
--- a/greedy_algorithms/knapsack.cpp
+++ b/greedy_algorithms/knapsack.cpp
@@ -3,90 +3,88 @@ using namespace std;
 
 struct Item
 {
-	int weight;
-	int profit;
+    int weight;
+    int profit;
 };
 
-float profitPerUnit(Item x)
-{
-	return (float)x.profit / (float)x.weight;
-}
+float profitPerUnit(Item x) { return (float)x.profit / (float)x.weight; }
 
 int partition(Item arr[], int low, int high)
 {
-	Item pivot = arr[high]; // pivot
-	int i = (low - 1);		// Index of smaller element
+    Item pivot = arr[high];  // pivot
+    int i = (low - 1);       // Index of smaller element
 
-	for (int j = low; j < high; j++)
-	{
-		// If current element is smaller than or
-		// equal to pivot
-		if (profitPerUnit(arr[j]) <= profitPerUnit(pivot))
-		{
-			i++; // increment index of smaller element
-			Item temp = arr[i];
-			arr[i] = arr[j];
-			arr[j] = temp;
-		}
-	}
-	Item temp = arr[i + 1];
-	arr[i + 1] = arr[high];
-	arr[high] = temp;
-	return (i + 1);
+    for (int j = low; j < high; j++)
+    {
+        // If current element is smaller than or
+        // equal to pivot
+        if (profitPerUnit(arr[j]) <= profitPerUnit(pivot))
+        {
+            i++;  // increment index of smaller element
+            Item temp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = temp;
+        }
+    }
+    Item temp = arr[i + 1];
+    arr[i + 1] = arr[high];
+    arr[high] = temp;
+    return (i + 1);
 }
 
 void quickSort(Item arr[], int low, int high)
 {
-	if (low < high)
-	{
+    if (low < high)
+    {
+        int p = partition(arr, low, high);
 
-		int p = partition(arr, low, high);
-
-		quickSort(arr, low, p - 1);
-		quickSort(arr, p + 1, high);
-	}
+        quickSort(arr, low, p - 1);
+        quickSort(arr, p + 1, high);
+    }
 }
 
 int main()
 {
-	cout << "\nEnter the capacity of the knapsack : ";
-	float capacity;
-	cin >> capacity;
-	cout << "\n Enter the number of Items : ";
-	int n;
-	cin >> n;
-	Item itemArray[n];
-	for (int i = 0; i < n; i++)
-	{
-		cout << "\nEnter the weight and profit of item " << i + 1 << " : ";
-		cin >> itemArray[i].weight;
-		cin >> itemArray[i].profit;
-	}
+    cout << "\nEnter the capacity of the knapsack : ";
+    float capacity;
+    cin >> capacity;
+    cout << "\n Enter the number of Items : ";
+    int n;
+    cin >> n;
+    Item itemArray[n];
+    for (int i = 0; i < n; i++)
+    {
+        cout << "\nEnter the weight and profit of item " << i + 1 << " : ";
+        cin >> itemArray[i].weight;
+        cin >> itemArray[i].profit;
+    }
 
-	quickSort(itemArray, 0, n - 1);
+    quickSort(itemArray, 0, n - 1);
 
-	// show(itemArray, n);
+    // show(itemArray, n);
 
-	float maxProfit = 0;
-	int i = n;
-	while (capacity > 0 && --i >= 0)
-	{
-		if (capacity >= itemArray[i].weight)
-		{
-			maxProfit += itemArray[i].profit;
-			capacity -= itemArray[i].weight;
-			cout << "\n\t" << itemArray[i].weight << "\t" << itemArray[i].profit;
-		}
-		else
-		{
-			maxProfit += profitPerUnit(itemArray[i]) * capacity;
-			cout << "\n\t" << capacity << "\t" << profitPerUnit(itemArray[i]) * capacity;
-			capacity = 0;
-			break;
-		}
-	}
+    float maxProfit = 0;
+    int i = n;
+    while (capacity > 0 && --i >= 0)
+    {
+        if (capacity >= itemArray[i].weight)
+        {
+            maxProfit += itemArray[i].profit;
+            capacity -= itemArray[i].weight;
+            cout << "\n\t" << itemArray[i].weight << "\t"
+                 << itemArray[i].profit;
+        }
+        else
+        {
+            maxProfit += profitPerUnit(itemArray[i]) * capacity;
+            cout << "\n\t" << capacity << "\t"
+                 << profitPerUnit(itemArray[i]) * capacity;
+            capacity = 0;
+            break;
+        }
+    }
 
-	cout << "\nMax Profit : " << maxProfit;
+    cout << "\nMax Profit : " << maxProfit;
 
-	return 0;
+    return 0;
 }
diff --git a/greedy_algorithms/kruskals_minimum_spanning_tree.cpp b/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
index 951d4a88a..feeaf0102 100644
--- a/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
+++ b/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
@@ -4,34 +4,33 @@ using namespace std;
 #define V 6
 #define INFINITY 99999
 
-int graph[V][V] = {
-	{0, 4, 1, 4, INFINITY, INFINITY},
-	{4, 0, 3, 8, 3, INFINITY},
-	{1, 3, 0, INFINITY, 1, INFINITY},
-	{4, 8, INFINITY, 0, 5, 7},
-	{INFINITY, 3, 1, 5, 0, INFINITY},
-	{INFINITY, INFINITY, INFINITY, 7, INFINITY, 0}};
+int graph[V][V] = {{0, 4, 1, 4, INFINITY, INFINITY},
+                   {4, 0, 3, 8, 3, INFINITY},
+                   {1, 3, 0, INFINITY, 1, INFINITY},
+                   {4, 8, INFINITY, 0, 5, 7},
+                   {INFINITY, 3, 1, 5, 0, INFINITY},
+                   {INFINITY, INFINITY, INFINITY, 7, INFINITY, 0}};
 
 void findMinimumEdge()
 {
-	for (int i = 0; i < V; i++)
-	{
-		int min = INFINITY;
-		int minIndex = 0;
-		for (int j = 0; j < V; j++)
-		{
-			if (graph[i][j] != 0 && graph[i][j] < min)
-			{
-				min = graph[i][j];
-				minIndex = j;
-			}
-		}
-		cout << i << "  -  " << minIndex << "\t" << graph[i][minIndex] << "\n";
-	}
+    for (int i = 0; i < V; i++)
+    {
+        int min = INFINITY;
+        int minIndex = 0;
+        for (int j = 0; j < V; j++)
+        {
+            if (graph[i][j] != 0 && graph[i][j] < min)
+            {
+                min = graph[i][j];
+                minIndex = j;
+            }
+        }
+        cout << i << "  -  " << minIndex << "\t" << graph[i][minIndex] << "\n";
+    }
 }
 
 int main()
 {
-	findMinimumEdge();
-	return 0;
+    findMinimumEdge();
+    return 0;
 }
diff --git a/greedy_algorithms/prims_minimum_spanning_tree.cpp b/greedy_algorithms/prims_minimum_spanning_tree.cpp
index 769ca64e4..c1d3df669 100644
--- a/greedy_algorithms/prims_minimum_spanning_tree.cpp
+++ b/greedy_algorithms/prims_minimum_spanning_tree.cpp
@@ -4,76 +4,74 @@ using namespace std;
 #define V 4
 #define INFINITY 99999
 
-int graph[V][V] = {
-	{0, 5, 1, 2},
-	{5, 0, 3, 3},
-	{1, 3, 0, 4},
-	{2, 3, 4, 0}};
+int graph[V][V] = {{0, 5, 1, 2}, {5, 0, 3, 3}, {1, 3, 0, 4}, {2, 3, 4, 0}};
 
 struct mst
 {
-	bool visited;
-	int key;
-	int near;
+    bool visited;
+    int key;
+    int near;
 };
 
 mst MST_Array[V];
 
 void initilize()
 {
-	for (int i = 0; i < V; i++)
-	{
-		MST_Array[i].visited = false;
-		MST_Array[i].key = INFINITY; // considering INFINITY as inifinity
-		MST_Array[i].near = i;
-	}
+    for (int i = 0; i < V; i++)
+    {
+        MST_Array[i].visited = false;
+        MST_Array[i].key = INFINITY;  // considering INFINITY as inifinity
+        MST_Array[i].near = i;
+    }
 
-	MST_Array[0].key = 0;
+    MST_Array[0].key = 0;
 }
 
 void updateNear()
 {
-	for (int v = 0; v < V; v++)
-	{
-		int min = INFINITY;
-		int minIndex = 0;
-		for (int i = 0; i < V; i++)
-		{
-			if (MST_Array[i].key < min && MST_Array[i].visited == false && MST_Array[i].key != INFINITY)
-			{
-				min = MST_Array[i].key;
-				minIndex = i;
-			}
-		}
+    for (int v = 0; v < V; v++)
+    {
+        int min = INFINITY;
+        int minIndex = 0;
+        for (int i = 0; i < V; i++)
+        {
+            if (MST_Array[i].key < min && MST_Array[i].visited == false &&
+                MST_Array[i].key != INFINITY)
+            {
+                min = MST_Array[i].key;
+                minIndex = i;
+            }
+        }
 
-		MST_Array[minIndex].visited = true;
+        MST_Array[minIndex].visited = true;
 
-		for (int i = 0; i < V; i++)
-		{
-			if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY)
-			{
-				if (graph[minIndex][i] < MST_Array[i].key)
-				{
-					MST_Array[i].key = graph[minIndex][i];
-					MST_Array[i].near = minIndex;
-				}
-			}
-		}
-	}
+        for (int i = 0; i < V; i++)
+        {
+            if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY)
+            {
+                if (graph[minIndex][i] < MST_Array[i].key)
+                {
+                    MST_Array[i].key = graph[minIndex][i];
+                    MST_Array[i].near = minIndex;
+                }
+            }
+        }
+    }
 }
 
 void show()
 {
-	for (int i = 0; i < V; i++)
-	{
-		cout << i << "  -  " << MST_Array[i].near << "\t" << graph[i][MST_Array[i].near] << "\n";
-	}
+    for (int i = 0; i < V; i++)
+    {
+        cout << i << "  -  " << MST_Array[i].near << "\t"
+             << graph[i][MST_Array[i].near] << "\n";
+    }
 }
 
 int main()
 {
-	initilize();
-	updateNear();
-	show();
-	return 0;
+    initilize();
+    updateNear();
+    show();
+    return 0;
 }
diff --git a/hashing/chaining.cpp b/hashing/chaining.cpp
index 55aa8961c..ae46aea59 100644
--- a/hashing/chaining.cpp
+++ b/hashing/chaining.cpp
@@ -1,140 +1,134 @@
-#include <iostream>
 #include <math.h>
+#include <iostream>
 using namespace std;
 
 struct Node
 {
-	int data;
-	struct Node *next;
+    int data;
+    struct Node *next;
 } * head[100], *curr;
 
 void init()
 {
-	for (int i = 0; i < 100; i++)
-		head[i] = NULL;
+    for (int i = 0; i < 100; i++) head[i] = NULL;
 }
 
 void add(int x, int h)
 {
-	struct Node *temp = new Node;
-	temp->data = x;
-	temp->next = NULL;
-	if (!head[h])
-	{
-		head[h] = temp;
-		curr = head[h];
-	}
-	else
-	{
-		curr = head[h];
-		while (curr->next)
-			curr = curr->next;
-		curr->next = temp;
-	}
+    struct Node *temp = new Node;
+    temp->data = x;
+    temp->next = NULL;
+    if (!head[h])
+    {
+        head[h] = temp;
+        curr = head[h];
+    }
+    else
+    {
+        curr = head[h];
+        while (curr->next) curr = curr->next;
+        curr->next = temp;
+    }
 }
 
 void display(int mod)
 {
-	struct Node *temp;
-	int i;
-	for (i = 0; i < mod; i++)
-	{
-		if (!head[i])
-		{
-			cout << "Key " << i << " is empty" << endl;
-		}
-		else
-		{
-			cout << "Key " << i << " has values = ";
-			temp = head[i];
-			while (temp->next)
-			{
-				cout << temp->data << " ";
-				temp = temp->next;
-			}
-			cout << temp->data;
-			cout << endl;
-		}
-	}
+    struct Node *temp;
+    int i;
+    for (i = 0; i < mod; i++)
+    {
+        if (!head[i])
+        {
+            cout << "Key " << i << " is empty" << endl;
+        }
+        else
+        {
+            cout << "Key " << i << " has values = ";
+            temp = head[i];
+            while (temp->next)
+            {
+                cout << temp->data << " ";
+                temp = temp->next;
+            }
+            cout << temp->data;
+            cout << endl;
+        }
+    }
 }
 
-int hash(int x, int mod)
-{
-	return x % mod;
-}
+int hash(int x, int mod) { return x % mod; }
 
 void find(int x, int h)
 {
-	struct Node *temp = head[h];
-	if (!head[h])
-	{
-		cout << "Element not found";
-		return;
-	}
-	while (temp->data != x && temp->next)
-		temp = temp->next;
-	if (temp->next)
-		cout << "Element found";
-	else
-	{
-		if (temp->data == x)
-			cout << "Element found";
-		else
-			cout << "Element not found";
-	}
+    struct Node *temp = head[h];
+    if (!head[h])
+    {
+        cout << "Element not found";
+        return;
+    }
+    while (temp->data != x && temp->next) temp = temp->next;
+    if (temp->next)
+        cout << "Element found";
+    else
+    {
+        if (temp->data == x)
+            cout << "Element found";
+        else
+            cout << "Element not found";
+    }
 }
 
 int main(void)
 {
-	init();
-	int c, x, mod, h;
-	cout << "Enter the size of Hash Table. = ";
-	cin >> mod;
-	bool loop = true;
-	while (loop)
-	{
-		cout << endl;
-		cout << "PLEASE CHOOSE -" << endl;
-		cout << "1. Add element." << endl;
-		cout << "2. Find element." << endl;
-		cout << "3. Generate Hash." << endl;
-		cout << "4. Display Hash table." << endl;
-		cout << "5. Exit." << endl;
-		cin >> c;
-		switch (c)
-		{
-		case 1:
-			cout << "Enter element to add = ";
-			cin >> x;
-			h = hash(x, mod);
-			h = fabs(h);
-			add(x, h);
-			break;
-		case 2:
-			cout << "Enter element to search = ";
-			cin >> x;
-			h = hash(x, mod);
-			find(x, h);
-			break;
-		case 3:
-			cout << "Enter element to generate hash = ";
-			cin >> x;
-			cout << "Hash of " << x << " is = " << hash(x, mod);
-			break;
-		case 4:
-			display(mod);
-			break;
-		default:
-			loop = false;
-			break;
-		}
-		cout << endl;
-	}
-	/*add(1,&head1);
-	add(2,&head1);
-	add(3,&head2);
-	add(5,&head1);
-	display(&head1);
-	display(&head2);*/
-	return 0;
+    init();
+    int c, x, mod, h;
+    cout << "Enter the size of Hash Table. = ";
+    cin >> mod;
+    bool loop = true;
+    while (loop)
+    {
+        cout << endl;
+        cout << "PLEASE CHOOSE -" << endl;
+        cout << "1. Add element." << endl;
+        cout << "2. Find element." << endl;
+        cout << "3. Generate Hash." << endl;
+        cout << "4. Display Hash table." << endl;
+        cout << "5. Exit." << endl;
+        cin >> c;
+        switch (c)
+        {
+        case 1:
+            cout << "Enter element to add = ";
+            cin >> x;
+            h = hash(x, mod);
+            h = fabs(h);
+            add(x, h);
+            break;
+        case 2:
+            cout << "Enter element to search = ";
+            cin >> x;
+            h = hash(x, mod);
+            find(x, h);
+            break;
+        case 3:
+            cout << "Enter element to generate hash = ";
+            cin >> x;
+            cout << "Hash of " << x << " is = " << hash(x, mod);
+            break;
+        case 4:
+            display(mod);
+            break;
+        default:
+            loop = false;
+            break;
+        }
+        cout << endl;
+    }
+    /*add(1,&head1);
+    add(2,&head1);
+    add(3,&head2);
+    add(5,&head1);
+    display(&head1);
+    display(&head2);*/
+    return 0;
 }
\ No newline at end of file
diff --git a/hashing/double_hash_hash_table.cpp b/hashing/double_hash_hash_table.cpp
index 6030b7ff3..842f383c5 100644
--- a/hashing/double_hash_hash_table.cpp
+++ b/hashing/double_hash_hash_table.cpp
@@ -1,13 +1,13 @@
 // Copyright 2019
 
-#include<stdlib.h>
-#include<iostream>
-#include<functional>
-#include<string>
+#include <stdlib.h>
+#include <functional>
+#include <iostream>
+#include <string>
 
-using std::endl;
-using std::cout;
 using std::cin;
+using std::cout;
+using std::endl;
 using std::string;
 
 // fwd declarations
@@ -25,53 +25,70 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry {
+struct Entry
+{
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key) {
+int hashFxn(int key)
+{
     std::hash<int> hash;
     return hash(key);
 }
 
 // Used for second hash function
-int otherHashFxn(int key) {
+int otherHashFxn(int key)
+{
     std::hash<int> hash;
     return 1 + (7 - (hash(key) % 7));
 }
 
 // Performs double hashing to resolve collisions
-int doubleHash(int key, bool searching) {
+int doubleHash(int key, bool searching)
+{
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do {
-        int index = static_cast<int>(fabs((hash +
-            (i * otherHashFxn(key))))) % totalSize;
+    do
+    {
+        int index = static_cast<int>(fabs((hash + (i * otherHashFxn(key))))) %
+                    totalSize;
         entry = table[index];
-        if (searching) {
-            if (entry.key == notPresent) {
+        if (searching)
+        {
+            if (entry.key == notPresent)
+            {
                 return notPresent;
             }
-            if (searchingProber(entry, key)) {
+            if (searchingProber(entry, key))
+            {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        } else {
-            if (putProber(entry, key)) {
-                if (!rehashing) cout << "Spot found!" << endl;
+        }
+        else
+        {
+            if (putProber(entry, key))
+            {
+                if (!rehashing)
+                    cout << "Spot found!" << endl;
                 return index;
             }
-            if (!rehashing) cout << "Spot taken, looking at next (next index:"
-                << " " << static_cast<int>(fabs((hash +
-                (i * otherHashFxn(key))))) % totalSize << ")" << endl;
+            if (!rehashing)
+                cout << "Spot taken, looking at next (next index:"
+                     << " "
+                     << static_cast<int>(
+                            fabs((hash + (i * otherHashFxn(key))))) %
+                            totalSize
+                     << ")" << endl;
             i++;
         }
-        if (i == totalSize * 100) {
+        if (i == totalSize * 100)
+        {
             cout << "DoubleHash probe failed" << endl;
             return notPresent;
         }
@@ -80,27 +97,38 @@ int doubleHash(int key, bool searching) {
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key) {
-    if (entry.key == notPresent || entry.key == tomb) {
+bool putProber(Entry entry, int key)
+{
+    if (entry.key == notPresent || entry.key == tomb)
+    {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key) {
-    if (entry.key == key) return true;
+bool searchingProber(Entry entry, int key)
+{
+    if (entry.key == key)
+        return true;
     return false;
 }
 
 // Displays the table
-void display() {
-    for (int i = 0; i < totalSize; i++) {
-        if (table[i].key == notPresent) {
+void display()
+{
+    for (int i = 0; i < totalSize; i++)
+    {
+        if (table[i].key == notPresent)
+        {
             cout << " Empty ";
-        } else if (table[i].key == tomb) {
+        }
+        else if (table[i].key == tomb)
+        {
             cout << " Tomb ";
-        } else {
+        }
+        else
+        {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -110,7 +138,8 @@ void display() {
 }
 
 // Rehashes the table into a bigger table
-void rehash() {
+void rehash()
+{
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -118,8 +147,10 @@ void rehash() {
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++) {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
+    for (int i = 0; i < oldSize; i++)
+    {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
+        {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -130,21 +161,25 @@ void rehash() {
 }
 
 // Checks for load factor here
-void add(int key) {
-    Entry * entry = new Entry();
+void add(int key)
+{
+    Entry* entry = new Entry();
     entry->key = key;
     int index = doubleHash(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size/ static_cast<double>(totalSize) >= 0.5) {
+    if (++size / static_cast<double>(totalSize) >= 0.5)
+    {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key) {
+void remove(int key)
+{
     int index = doubleHash(key, true);
-    if (index == notPresent) {
+    if (index == notPresent)
+    {
         cout << "key not found" << endl;
     }
     table[index].key = tomb;
@@ -153,12 +188,13 @@ void remove(int key) {
 }
 
 // Information about the adding process
-void addInfo(int key) {
+void addInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << fabs(hashFxn(key) % totalSize);
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << fabs(hashFxn(key) % totalSize);
     cout << endl;
     add(key);
     cout << "New table: ";
@@ -166,12 +202,13 @@ void addInfo(int key) {
 }
 
 // Information about removal process
-void removalInfo(int key) {
+void removalInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << hashFxn(key) % totalSize;
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << hashFxn(key) % totalSize;
     cout << endl;
     remove(key);
     cout << "New table: ";
@@ -179,13 +216,15 @@ void removalInfo(int key) {
 }
 
 // I/O
-int main(void) {
+int main(void)
+{
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop) {
+    while (loop)
+    {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -196,7 +235,8 @@ int main(void) {
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd) {
+        switch (cmd)
+        {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -207,11 +247,13 @@ int main(void) {
             cin >> key;
             removalInfo(key);
             break;
-        case 3: {
+        case 3:
+        {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[doubleHash(key, true)];
-            if (entry.key == notPresent) {
+            if (entry.key == notPresent)
+            {
                 cout << "Key not present";
             }
             break;
diff --git a/hashing/linear_probing_hash_table.cpp b/hashing/linear_probing_hash_table.cpp
index b00eb8641..0d4b5b0e1 100644
--- a/hashing/linear_probing_hash_table.cpp
+++ b/hashing/linear_probing_hash_table.cpp
@@ -1,13 +1,13 @@
 // Copyright 2019
 
-#include<stdlib.h>
-#include<iostream>
-#include<functional>
-#include<string>
+#include <stdlib.h>
+#include <functional>
+#include <iostream>
+#include <string>
 
-using std::endl;
-using std::cout;
 using std::cin;
+using std::cout;
+using std::endl;
 using std::string;
 
 // fwd declarations
@@ -25,44 +25,57 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry {
+struct Entry
+{
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key) {
+int hashFxn(int key)
+{
     std::hash<int> hash;
     return hash(key);
 }
 
 // Performs linear probing to resolve collisions
-int linearProbe(int key, bool searching) {
+int linearProbe(int key, bool searching)
+{
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do {
+    do
+    {
         int index = static_cast<int>(fabs((hash + i) % totalSize));
         entry = table[index];
-        if (searching) {
-            if (entry.key == notPresent) {
+        if (searching)
+        {
+            if (entry.key == notPresent)
+            {
                 return notPresent;
             }
-            if (searchingProber(entry, key)) {
+            if (searchingProber(entry, key))
+            {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        } else {
-            if (putProber(entry, key)) {
-                if (!rehashing) cout << "Spot found!" << endl;
+        }
+        else
+        {
+            if (putProber(entry, key))
+            {
+                if (!rehashing)
+                    cout << "Spot found!" << endl;
                 return index;
             }
-            if (!rehashing) cout << "Spot taken, looking at next" << endl;
+            if (!rehashing)
+                cout << "Spot taken, looking at next" << endl;
             i++;
         }
-        if (i == totalSize) {
+        if (i == totalSize)
+        {
             cout << "Linear probe failed" << endl;
             return notPresent;
         }
@@ -71,27 +84,38 @@ int linearProbe(int key, bool searching) {
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key) {
-    if (entry.key == notPresent || entry.key == tomb) {
+bool putProber(Entry entry, int key)
+{
+    if (entry.key == notPresent || entry.key == tomb)
+    {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key) {
-    if (entry.key == key) return true;
+bool searchingProber(Entry entry, int key)
+{
+    if (entry.key == key)
+        return true;
     return false;
 }
 
 // Displays the table
-void display() {
-    for (int i = 0; i < totalSize; i++) {
-        if (table[i].key == notPresent) {
+void display()
+{
+    for (int i = 0; i < totalSize; i++)
+    {
+        if (table[i].key == notPresent)
+        {
             cout << " Empty ";
-        } else if (table[i].key == tomb) {
+        }
+        else if (table[i].key == tomb)
+        {
             cout << " Tomb ";
-        } else {
+        }
+        else
+        {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -101,7 +125,8 @@ void display() {
 }
 
 // Rehashes the table into a bigger table
-void rehash() {
+void rehash()
+{
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -109,8 +134,10 @@ void rehash() {
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++) {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
+    for (int i = 0; i < oldSize; i++)
+    {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
+        {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -121,21 +148,25 @@ void rehash() {
 }
 
 // Adds entry using linear probing. Checks for load factor here
-void add(int key) {
-    Entry * entry = new Entry();
+void add(int key)
+{
+    Entry* entry = new Entry();
     entry->key = key;
     int index = linearProbe(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size/ static_cast<double>(totalSize) >= 0.5) {
+    if (++size / static_cast<double>(totalSize) >= 0.5)
+    {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key) {
+void remove(int key)
+{
     int index = linearProbe(key, true);
-    if (index == notPresent) {
+    if (index == notPresent)
+    {
         cout << "key not found" << endl;
     }
     cout << "Removal Successful, leaving tomb" << endl;
@@ -144,12 +175,13 @@ void remove(int key) {
 }
 
 // Information about the adding process
-void addInfo(int key) {
+void addInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key) << " % "
-        << totalSize << " == " << fabs(hashFxn(key) % totalSize);
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << fabs(hashFxn(key) % totalSize);
     cout << endl;
     add(key);
     cout << "New table: ";
@@ -157,12 +189,13 @@ void addInfo(int key) {
 }
 
 // Information about removal process
-void removalInfo(int key) {
+void removalInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << hashFxn(key) % totalSize;
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << hashFxn(key) % totalSize;
     cout << endl;
     remove(key);
     cout << "New table: ";
@@ -170,13 +203,15 @@ void removalInfo(int key) {
 }
 
 // I/O
-int main(void) {
+int main(void)
+{
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop) {
+    while (loop)
+    {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -187,7 +222,8 @@ int main(void) {
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd) {
+        switch (cmd)
+        {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -198,11 +234,13 @@ int main(void) {
             cin >> key;
             removalInfo(key);
             break;
-        case 3: {
+        case 3:
+        {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[linearProbe(key, true)];
-            if (entry.key == notPresent) {
+            if (entry.key == notPresent)
+            {
                 cout << "Key not present";
             }
             break;
diff --git a/hashing/quadratic_probing_hash_table.cpp b/hashing/quadratic_probing_hash_table.cpp
index 44e2e3b9f..b549d057d 100644
--- a/hashing/quadratic_probing_hash_table.cpp
+++ b/hashing/quadratic_probing_hash_table.cpp
@@ -1,14 +1,14 @@
 // Copyright 2019
 
-#include<stdlib.h>
-#include<iostream>
-#include<functional>
-#include<string>
-#include<cmath>
+#include <stdlib.h>
+#include <cmath>
+#include <functional>
+#include <iostream>
+#include <string>
 
-using std::endl;
-using std::cout;
 using std::cin;
+using std::cout;
+using std::endl;
 using std::string;
 
 // fwd declarations
@@ -26,49 +26,64 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry {
+struct Entry
+{
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key) {
+int hashFxn(int key)
+{
     std::hash<int> hash;
     return hash(key);
 }
 
 // Performs quadratic probing to resolve collisions
-int quadraticProbe(int key, bool searching) {
+int quadraticProbe(int key, bool searching)
+{
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do {
-        int index = std::round(fabs((hash +
-            static_cast<int>(std::round(std::pow(i, 2)))) % totalSize));
+    do
+    {
+        int index = std::round(fabs(
+            (hash + static_cast<int>(std::round(std::pow(i, 2)))) % totalSize));
         entry = table[index];
-        if (searching) {
-            if (entry.key == notPresent) {
+        if (searching)
+        {
+            if (entry.key == notPresent)
+            {
                 return notPresent;
             }
-            if (searchingProber(entry, key)) {
+            if (searchingProber(entry, key))
+            {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        } else {
-            if (putProber(entry, key)) {
-                if (!rehashing) cout << "Spot found!" << endl;
+        }
+        else
+        {
+            if (putProber(entry, key))
+            {
+                if (!rehashing)
+                    cout << "Spot found!" << endl;
                 return index;
             }
-            if (!rehashing) {
-                cout << "Spot taken, looking at next (next index = " <<
-                    std::round(fabs((hash + static_cast<int>(std::round(
-                        std::pow(i + 1, 2)))) % totalSize)) << endl;
+            if (!rehashing)
+            {
+                cout << "Spot taken, looking at next (next index = "
+                     << std::round(fabs((hash + static_cast<int>(std::round(
+                                                    std::pow(i + 1, 2)))) %
+                                        totalSize))
+                     << endl;
             }
             i++;
         }
-        if (i == totalSize * 100) {
+        if (i == totalSize * 100)
+        {
             cout << "Quadratic probe failed (infinite loop)" << endl;
             return notPresent;
         }
@@ -77,34 +92,47 @@ int quadraticProbe(int key, bool searching) {
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key) {
-    if (entry.key == notPresent || entry.key == tomb) {
+bool putProber(Entry entry, int key)
+{
+    if (entry.key == notPresent || entry.key == tomb)
+    {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key) {
-    if (entry.key == key) return true;
+bool searchingProber(Entry entry, int key)
+{
+    if (entry.key == key)
+        return true;
     return false;
 }
 
 // Helper
-Entry find(int key) {
+Entry find(int key)
+{
     int index = quadraticProbe(key, true);
-    if (index == notPresent) return Entry();
+    if (index == notPresent)
+        return Entry();
     return table[index];
 }
 
 // Displays the table
-void display() {
-    for (int i = 0; i < totalSize; i++) {
-        if (table[i].key == notPresent) {
+void display()
+{
+    for (int i = 0; i < totalSize; i++)
+    {
+        if (table[i].key == notPresent)
+        {
             cout << " Empty ";
-        } else if (table[i].key == tomb) {
+        }
+        else if (table[i].key == tomb)
+        {
             cout << " Tomb ";
-        } else {
+        }
+        else
+        {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -114,7 +142,8 @@ void display() {
 }
 
 // Rehashes the table into a bigger table
-void rehash() {
+void rehash()
+{
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -122,8 +151,10 @@ void rehash() {
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++) {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
+    for (int i = 0; i < oldSize; i++)
+    {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
+        {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -134,21 +165,25 @@ void rehash() {
 }
 
 // Checks for load factor here
-void add(int key) {
-    Entry * entry = new Entry();
+void add(int key)
+{
+    Entry* entry = new Entry();
     entry->key = key;
     int index = quadraticProbe(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size/ static_cast<double>(totalSize) >= 0.5) {
+    if (++size / static_cast<double>(totalSize) >= 0.5)
+    {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key) {
+void remove(int key)
+{
     int index = quadraticProbe(key, true);
-    if (index == notPresent) {
+    if (index == notPresent)
+    {
         cout << "key not found" << endl;
     }
     table[index].key = tomb;
@@ -157,12 +192,13 @@ void remove(int key) {
 }
 
 // Information about the adding process
-void addInfo(int key) {
+void addInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key) << " % "
-        << totalSize << " == " << fabs(hashFxn(key) % totalSize);
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << fabs(hashFxn(key) % totalSize);
     cout << endl;
     add(key);
     cout << "New table: ";
@@ -170,12 +206,13 @@ void addInfo(int key) {
 }
 
 // Information about removal process
-void removalInfo(int key) {
+void removalInfo(int key)
+{
     cout << "Initial table: ";
     display();
     cout << endl;
-    cout << "hash of " << key << " is " << hashFxn(key)
-        << " % " << totalSize << " == " << hashFxn(key) % totalSize;
+    cout << "hash of " << key << " is " << hashFxn(key) << " % " << totalSize
+         << " == " << hashFxn(key) % totalSize;
     cout << endl;
     remove(key);
     cout << "New table: ";
@@ -183,13 +220,15 @@ void removalInfo(int key) {
 }
 
 // I/O
-int main(void) {
+int main(void)
+{
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop) {
+    while (loop)
+    {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -200,7 +239,8 @@ int main(void) {
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd) {
+        switch (cmd)
+        {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -211,11 +251,13 @@ int main(void) {
             cin >> key;
             removalInfo(key);
             break;
-        case 3: {
+        case 3:
+        {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[quadraticProbe(key, true)];
-            if (entry.key == notPresent) {
+            if (entry.key == notPresent)
+            {
                 cout << "Key not present";
             }
             break;
diff --git a/math/binary_exponent.cpp b/math/binary_exponent.cpp
index 05e6f33f7..7bf3a34a1 100644
--- a/math/binary_exponent.cpp
+++ b/math/binary_exponent.cpp
@@ -25,24 +25,32 @@
 
 /// Recursive function to calculate exponent in \f$O(\log(n))\f$ using binary
 /// exponent.
-int binExpo(int a, int b) {
-    if (b == 0) {
+int binExpo(int a, int b)
+{
+    if (b == 0)
+    {
         return 1;
     }
     int res = binExpo(a, b / 2);
-    if (b % 2) {
+    if (b % 2)
+    {
         return res * res * a;
-    } else {
+    }
+    else
+    {
         return res * res;
     }
 }
 
 /// Iterative function to calculate exponent in \f$O(\log(n))\f$ using binary
 /// exponent.
-int binExpo_alt(int a, int b) {
+int binExpo_alt(int a, int b)
+{
     int res = 1;
-    while (b > 0) {
-        if (b % 2) {
+    while (b > 0)
+    {
+        if (b % 2)
+        {
             res = res * a;
         }
         a = a * a;
@@ -52,15 +60,21 @@ int binExpo_alt(int a, int b) {
 }
 
 /// Main function
-int main() {
+int main()
+{
     int a, b;
     /// Give two numbers a, b
     std::cin >> a >> b;
-    if (a == 0 && b == 0) {
+    if (a == 0 && b == 0)
+    {
         std::cout << "Math error" << std::endl;
-    } else if (b < 0) {
+    }
+    else if (b < 0)
+    {
         std::cout << "Exponent must be positive !!" << std::endl;
-    } else {
+    }
+    else
+    {
         int resRecurse = binExpo(a, b);
         /// int resIterate = binExpo_alt(a, b);
 
diff --git a/math/double_factorial.cpp b/math/double_factorial.cpp
index 37bd2052a..4909ad489 100644
--- a/math/double_factorial.cpp
+++ b/math/double_factorial.cpp
@@ -13,10 +13,13 @@
 
 /** Compute double factorial using iterative method
  */
-uint64_t double_factorial_iterative(uint64_t n) {
+uint64_t double_factorial_iterative(uint64_t n)
+{
     uint64_t res = 1;
-    for (uint64_t i = n;; i -= 2) {
-        if (i == 0 || i == 1) return res;
+    for (uint64_t i = n;; i -= 2)
+    {
+        if (i == 0 || i == 1)
+            return res;
         res *= i;
     }
     return res;
@@ -25,13 +28,16 @@ uint64_t double_factorial_iterative(uint64_t n) {
 /** Compute double factorial using resursive method.
  * <br/>Recursion can be costly for large numbers.
  */
-uint64_t double_factorial_recursive(uint64_t n) {
-    if (n <= 1) return 1;
+uint64_t double_factorial_recursive(uint64_t n)
+{
+    if (n <= 1)
+        return 1;
     return n * double_factorial_recursive(n - 2);
 }
 
 /// main function
-int main() {
+int main()
+{
     uint64_t n;
     std::cin >> n;
     assert(n >= 0);
diff --git a/math/eulers_totient_function.cpp b/math/eulers_totient_function.cpp
index e7f6fbf7f..283516b42 100644
--- a/math/eulers_totient_function.cpp
+++ b/math/eulers_totient_function.cpp
@@ -29,26 +29,35 @@
 
 /** Function to caculate Euler's totient phi
  */
-uint64_t phiFunction(uint64_t n) {
+uint64_t phiFunction(uint64_t n)
+{
     uint64_t result = n;
-    for (uint64_t i = 2; i * i <= n; i++) {
-        if (n % i == 0) {
-            while (n % i == 0) {
+    for (uint64_t i = 2; i * i <= n; i++)
+    {
+        if (n % i == 0)
+        {
+            while (n % i == 0)
+            {
                 n /= i;
             }
             result -= result / i;
         }
     }
-    if (n > 1) result -= result / n;
+    if (n > 1)
+        result -= result / n;
     return result;
 }
 
 /// Main function
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     uint64_t n;
-    if (argc < 2) {
+    if (argc < 2)
+    {
         std::cout << "Enter the number: ";
-    } else {
+    }
+    else
+    {
         n = strtoull(argv[1], nullptr, 10);
     }
     std::cin >> n;
diff --git a/math/extended_euclid_algorithm.cpp b/math/extended_euclid_algorithm.cpp
index 3fdae25b5..8a79e0c78 100644
--- a/math/extended_euclid_algorithm.cpp
+++ b/math/extended_euclid_algorithm.cpp
@@ -21,7 +21,8 @@
  * @param[in] quotient  unsigned
  */
 template <typename T, typename T2>
-inline void update_step(T *r, T *r0, const T2 quotient) {
+inline void update_step(T *r, T *r0, const T2 quotient)
+{
     T temp = *r;
     *r = *r0 - (quotient * temp);
     *r0 = temp;
@@ -38,14 +39,17 @@ inline void update_step(T *r, T *r0, const T2 quotient) {
  * @param[out] y signed
  */
 template <typename T1, typename T2>
-void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y) {
-    if (B > A) std::swap(A, B);  // Ensure that A >= B
+void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y)
+{
+    if (B > A)
+        std::swap(A, B);  // Ensure that A >= B
 
     T2 s = 0, s0 = 1;
     T2 t = 1, t0 = 0;
     T1 r = B, r0 = A;
 
-    while (r != 0) {
+    while (r != 0)
+    {
         T1 quotient = r0 / r;
         update_step(&r, &r0, quotient);
         update_step(&s, &s0, quotient);
@@ -66,14 +70,19 @@ void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y) {
  * @param[in,out] y signed
  */
 template <typename T, typename T2>
-void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
-    if (B > A) std::swap(A, B);  // Ensure that A >= B
+void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y)
+{
+    if (B > A)
+        std::swap(A, B);  // Ensure that A >= B
 
-    if (B == 0) {
+    if (B == 0)
+    {
         *GCD = A;
         *x = 1;
         *y = 0;
-    } else {
+    }
+    else
+    {
         extendedEuclid(B, A % B, GCD, x, y);
         T2 temp = *x;
         *x = *y;
@@ -82,7 +91,8 @@ void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
 }
 
 /// Main function
-int main() {
+int main()
+{
     uint32_t a, b, gcd;
     int32_t x, y;
     std::cin >> a >> b;
diff --git a/math/factorial.cpp b/math/factorial.cpp
index 353f0b16b..7f50544e2 100644
--- a/math/factorial.cpp
+++ b/math/factorial.cpp
@@ -5,14 +5,16 @@
 #include <iostream>
 
 /** function to find factorial of given number */
-unsigned int factorial(unsigned int n) {
+unsigned int factorial(unsigned int n)
+{
     if (n == 0)
         return 1;
     return n * factorial(n - 1);
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int num = 5;
     std::cout << "Factorial of " << num << " is " << factorial(num)
               << std::endl;
diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index d4de07460..8a0525ac1 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -23,11 +23,14 @@
  * algorithm implementation for \f$a^b\f$
  */
 template <typename T>
-double fast_power_recursive(T a, T b) {
+double fast_power_recursive(T a, T b)
+{
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0) return 1.0 / fast_power_recursive(a, -b);
+    if (b < 0)
+        return 1.0 / fast_power_recursive(a, -b);
 
-    if (b == 0) return 1;
+    if (b == 0)
+        return 1;
     T bottom = fast_power_recursive(a, b >> 1);
     // Since it is integer division b/2 = (b-1)/2 where b is odd.
     // Therefore, case2 is easily solved by integer division.
@@ -45,13 +48,17 @@ double fast_power_recursive(T a, T b) {
     It still calculates in \f$O(\log N)\f$
 */
 template <typename T>
-double fast_power_linear(T a, T b) {
+double fast_power_linear(T a, T b)
+{
     // negative power. a^b = 1 / (a^-b)
-    if (b < 0) return 1.0 / fast_power_linear(a, -b);
+    if (b < 0)
+        return 1.0 / fast_power_linear(a, -b);
 
     double result = 1;
-    while (b) {
-        if (b & 1) result = result * a;
+    while (b)
+    {
+        if (b & 1)
+            result = result * a;
         a = a * a;
         b = b >> 1;
     }
@@ -61,12 +68,14 @@ double fast_power_linear(T a, T b) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     std::srand(std::time(nullptr));
     std::ios_base::sync_with_stdio(false);
 
     std::cout << "Testing..." << std::endl;
-    for (int i = 0; i < 20; i++) {
+    for (int i = 0; i < 20; i++)
+    {
         int a = std::rand() % 20 - 10;
         int b = std::rand() % 20 - 10;
         std::cout << std::endl << "Calculating " << a << "^" << b << std::endl;
diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index e15cfc0cc..5a219bbf9 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -14,7 +14,8 @@
 /**
  * Recursively compute sequences
  */
-int fibonacci(unsigned int n) {
+int fibonacci(unsigned int n)
+{
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
     if (n <= 1)
@@ -25,7 +26,8 @@ int fibonacci(unsigned int n) {
 }
 
 /// Main function
-int main() {
+int main()
+{
     int n;
     std::cin >> n;
     assert(n >= 0);
diff --git a/math/fibonacci_fast.cpp b/math/fibonacci_fast.cpp
index 08cced351..3b3a3ca38 100644
--- a/math/fibonacci_fast.cpp
+++ b/math/fibonacci_fast.cpp
@@ -26,7 +26,8 @@ const uint64_t MAX = 93;
 uint64_t f[MAX] = {0};
 
 /** Algorithm */
-uint64_t fib(uint64_t n) {
+uint64_t fib(uint64_t n)
+{
     if (n == 0)
         return 0;
     if (n == 1 || n == 2)
@@ -43,9 +44,11 @@ uint64_t fib(uint64_t n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     // Main Function
-    for (uint64_t i = 1; i < 93; i++) {
+    for (uint64_t i = 1; i < 93; i++)
+    {
         std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
     }
     return 0;
diff --git a/math/fibonacci_large.cpp b/math/fibonacci_large.cpp
index d9dbff799..edc513750 100644
--- a/math/fibonacci_large.cpp
+++ b/math/fibonacci_large.cpp
@@ -20,11 +20,13 @@
  * \f[f(n)=f(n-1)+f(n-2)\f]
  * and returns the result as a large_number type.
  */
-large_number fib(uint64_t n) {
+large_number fib(uint64_t n)
+{
     large_number f0(1);
     large_number f1(1);
 
-    do {
+    do
+    {
         large_number f2 = f1;
         f1 += f0;
         f0 = f2;
@@ -34,11 +36,15 @@ large_number fib(uint64_t n) {
     return f1;
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     uint64_t N;
-    if (argc == 2) {
+    if (argc == 2)
+    {
         N = strtoull(argv[1], NULL, 10);
-    } else {
+    }
+    else
+    {
         std::cout << "Enter N: ";
         std::cin >> N;
     }
diff --git a/math/gcd_iterative_euclidean.cpp b/math/gcd_iterative_euclidean.cpp
index 2c0651ad7..e832605d7 100644
--- a/math/gcd_iterative_euclidean.cpp
+++ b/math/gcd_iterative_euclidean.cpp
@@ -12,27 +12,34 @@
 /**
  * algorithm
  */
-int gcd(int num1, int num2) {
-    if (num1 <= 0 | num2 <= 0) {
+int gcd(int num1, int num2)
+{
+    if (num1 <= 0 | num2 <= 0)
+    {
         throw std::domain_error("Euclidean algorithm domain is for ints > 0");
     }
 
-    if (num1 == num2) {
+    if (num1 == num2)
+    {
         return num1;
     }
 
     int base_num = 0;
     int previous_remainder = 1;
 
-    if (num1 > num2) {
+    if (num1 > num2)
+    {
         base_num = num1;
         previous_remainder = num2;
-    } else {
+    }
+    else
+    {
         base_num = num2;
         previous_remainder = num1;
     }
 
-    while ((base_num % previous_remainder) != 0) {
+    while ((base_num % previous_remainder) != 0)
+    {
         int old_base = base_num;
         base_num = previous_remainder;
         previous_remainder = old_base % previous_remainder;
@@ -44,11 +51,15 @@ int gcd(int num1, int num2) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
-    try {
+    try
+    {
         std::cout << "gcd of -120,10 is " << gcd(-120, 10) << std::endl;
-    } catch (const std::domain_error &e) {
+    }
+    catch (const std::domain_error &e)
+    {
         std::cout << "Error handling was successful" << std::endl;
     }
     std::cout << "gcd of 312,221 is " << (gcd(312, 221)) << std::endl;
diff --git a/math/gcd_of_n_numbers.cpp b/math/gcd_of_n_numbers.cpp
index 92968ff12..cd81e6025 100644
--- a/math/gcd_of_n_numbers.cpp
+++ b/math/gcd_of_n_numbers.cpp
@@ -12,10 +12,12 @@
  * @param[in] a array of integers to compute GCD for
  * @param[in] n number of integers in array `a`
  */
-int gcd(int *a, int n) {
+int gcd(int *a, int n)
+{
     int j = 1;  // to access all elements of the array starting from 1
     int gcd = a[0];
-    while (j < n) {
+    while (j < n)
+    {
         if (a[j] % gcd == 0)  // value of gcd is as needed so far
             j++;              // so we check for next element
         else
@@ -25,7 +27,8 @@ int gcd(int *a, int n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int n;
     std::cout << "Enter value of n:" << std::endl;
     std::cin >> n;
diff --git a/math/gcd_recursive_euclidean.cpp b/math/gcd_recursive_euclidean.cpp
index 2a3d2183c..d16fb1190 100644
--- a/math/gcd_recursive_euclidean.cpp
+++ b/math/gcd_recursive_euclidean.cpp
@@ -11,12 +11,15 @@
 /**
  * algorithm
  */
-int gcd(int num1, int num2) {
-    if (num1 <= 0 | num2 <= 0) {
+int gcd(int num1, int num2)
+{
+    if (num1 <= 0 | num2 <= 0)
+    {
         throw std::domain_error("Euclidean algorithm domain is for ints > 0");
     }
 
-    if (num1 == num2) {
+    if (num1 == num2)
+    {
         return num1;
     }
 
@@ -39,11 +42,15 @@ int gcd(int num1, int num2) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
-    try {
+    try
+    {
         std::cout << "gcd of -120,10 is " << gcd(-120, 10) << std::endl;
-    } catch (const std::domain_error &e) {
+    }
+    catch (const std::domain_error &e)
+    {
         std::cout << "Error handling was successful" << std::endl;
     }
     std::cout << "gcd of 312,221 is " << (gcd(312, 221)) << std::endl;
diff --git a/math/large_factorial.cpp b/math/large_factorial.cpp
index 1027f41ab..0a54f620b 100644
--- a/math/large_factorial.cpp
+++ b/math/large_factorial.cpp
@@ -13,7 +13,8 @@
 /** Test implementation for 10! Result must be 3628800.
  * @returns True if test pass else False
  */
-bool test1() {
+bool test1()
+{
     std::cout << "---- Check 1\t";
     unsigned int i, number = 10;
     large_number result;
@@ -23,15 +24,18 @@ bool test1() {
     const char *known_reslt = "3628800";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits()) {
+    if (strlen(known_reslt) != result.num_digits())
+    {
         std::cerr << "Result lengths dont match! " << strlen(known_reslt)
                   << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++) {
-        if (known_reslt[i] != result.digit_char(i)) {
+    for (i = 0; i < N; i++)
+    {
+        if (known_reslt[i] != result.digit_char(i))
+        {
             std::cerr << i << "^th digit mismatch! " << known_reslt[i]
                       << " != " << result.digit_char(i) << std::endl;
             return false;
@@ -50,7 +54,8 @@ bool test1() {
  * ```
  * @returns True if test pass else False
  */
-bool test2() {
+bool test2()
+{
     std::cout << "---- Check 2\t";
     unsigned int i, number = 100;
     large_number result;
@@ -63,15 +68,18 @@ bool test2() {
         "000000000000000000";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits()) {
+    if (strlen(known_reslt) != result.num_digits())
+    {
         std::cerr << "Result lengths dont match! " << strlen(known_reslt)
                   << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++) {
-        if (known_reslt[i] != result.digit_char(i)) {
+    for (i = 0; i < N; i++)
+    {
+        if (known_reslt[i] != result.digit_char(i))
+        {
             std::cerr << i << "^th digit mismatch! " << known_reslt[i]
                       << " != " << result.digit_char(i) << std::endl;
             return false;
@@ -85,12 +93,16 @@ bool test2() {
 /**
  * Main program
  **/
-int main(int argc, char *argv[]) {
+int main(int argc, char *argv[])
+{
     int number, i;
 
-    if (argc == 2) {
+    if (argc == 2)
+    {
         number = atoi(argv[1]);
-    } else {
+    }
+    else
+    {
         std::cout << "Enter the value of n(n starts from 0 ): ";
         std::cin >> number;
     }
diff --git a/math/large_number.h b/math/large_number.h
index c1a3665e4..88e3ba802 100644
--- a/math/large_number.h
+++ b/math/large_number.h
@@ -20,7 +20,8 @@
  * digit to the number, perform multiplication of
  * large number with long unsigned integers.
  **/
-class large_number {
+class large_number
+{
  public:
     /**< initializer with value = 1 */
     large_number() { _digits.push_back(1); }
@@ -35,9 +36,11 @@ class large_number {
     // }
 
     /**< initializer from an integer */
-    explicit large_number(int n) {
+    explicit large_number(int n)
+    {
         int carry = n;
-        do {
+        do
+        {
             add_digit(carry % 10);
             carry /= 10;
         } while (carry != 0);
@@ -50,8 +53,10 @@ class large_number {
     explicit large_number(std::vector<unsigned char> &vec) : _digits(vec) {}
 
     /**< initializer from a string */
-    explicit large_number(char const *number_str) {
-        for (size_t i = strlen(number_str); i > 0; i--) {
+    explicit large_number(char const *number_str)
+    {
+        for (size_t i = strlen(number_str); i > 0; i--)
+        {
             unsigned char a = number_str[i - 1] - '0';
             if (a >= 0 && a <= 9)
                 _digits.push_back(a);
@@ -61,48 +66,55 @@ class large_number {
     /**
      * Function to check implementation
      **/
-    static bool test() {
+    static bool test()
+    {
         std::cout << "------ Checking `large_number` class implementations\t"
                   << std::endl;
         large_number a(40);
         // 1. test multiplication
         a *= 10;
-        if (a != large_number(400)) {
+        if (a != large_number(400))
+        {
             std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 1/6...";
         // 2. test compound addition with integer
         a += 120;
-        if (a != large_number(520)) {
+        if (a != large_number(520))
+        {
             std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 2/6...";
         // 3. test compound multiplication again
         a *= 10;
-        if (a != large_number(5200)) {
+        if (a != large_number(5200))
+        {
             std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 3/6...";
         // 4. test increment (prefix)
         ++a;
-        if (a != large_number(5201)) {
+        if (a != large_number(5201))
+        {
             std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 4/6...";
         // 5. test increment (postfix)
         a++;
-        if (a != large_number(5202)) {
+        if (a != large_number(5202))
+        {
             std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 5/6...";
         // 6. test addition with another large number
         a = a + large_number("7000000000000000000000000000000");
-        if (a != large_number("7000000000000000000000000005202")) {
+        if (a != large_number("7000000000000000000000000005202"))
+        {
             std::cerr << "\tFailed 6/6 (" << a
                       << "!=7000000000000000000000000005202)" << std::endl;
             return false;
@@ -114,8 +126,10 @@ class large_number {
     /**
      * add a digit at MSB to the large number
      **/
-    void add_digit(unsigned int value) {
-        if (value > 9) {
+    void add_digit(unsigned int value)
+    {
+        if (value > 9)
+        {
             std::cerr << "digit > 9!!\n";
             exit(EXIT_FAILURE);
         }
@@ -135,14 +149,16 @@ class large_number {
      **/
     inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
 
-    inline const unsigned char &operator[](size_t n) const {
+    inline const unsigned char &operator[](size_t n) const
+    {
         return this->_digits[n];
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
+    friend std::ostream &operator<<(std::ostream &out, const large_number &a)
+    {
         for (size_t i = a.num_digits(); i > 0; i--)
             out << static_cast<int>(a[i - 1]);
         return out;
@@ -151,7 +167,8 @@ class large_number {
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator==(large_number const &a, large_number const &b) {
+    friend bool operator==(large_number const &a, large_number const &b)
+    {
         size_t N = a.num_digits();
         if (N != b.num_digits())
             return false;
@@ -164,14 +181,16 @@ class large_number {
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator!=(large_number const &a, large_number const &b) {
+    friend bool operator!=(large_number const &a, large_number const &b)
+    {
         return !(a == b);
     }
 
     /**
      * operator overload to increment (prefix)
      **/
-    large_number &operator++() {
+    large_number &operator++()
+    {
         (*this) += 1;
         return *this;
     }
@@ -179,7 +198,8 @@ class large_number {
     /**
      * operator overload to increment (postfix)
      **/
-    large_number &operator++(int) {
+    large_number &operator++(int)
+    {
         static large_number tmp(_digits);
         ++(*this);
         return tmp;
@@ -188,13 +208,15 @@ class large_number {
     /**
      * operator overload to add
      **/
-    large_number &operator+=(large_number n) {
+    large_number &operator+=(large_number n)
+    {
         // if adding with another large_number
         large_number *b = reinterpret_cast<large_number *>(&n);
         const size_t max_L = std::max(this->num_digits(), b->num_digits());
         unsigned int carry = 0;
         size_t i;
-        for (i = 0; i < max_L || carry != 0; i++) {
+        for (i = 0; i < max_L || carry != 0; i++)
+        {
             if (i < b->num_digits())
                 carry += (*b)[i];
             if (i < this->num_digits())
@@ -216,7 +238,8 @@ class large_number {
      * operator overload to perform addition
      **/
     template <class T>
-    friend large_number &operator+(const large_number &a, const T &b) {
+    friend large_number &operator+(const large_number &a, const T &b)
+    {
         static large_number c = a;
         c += b;
         return c;
@@ -225,7 +248,8 @@ class large_number {
     /**
      * assignment operator
      **/
-    large_number &operator=(const large_number &b) {
+    large_number &operator=(const large_number &b)
+    {
         this->_digits = b._digits;
         return *this;
     }
@@ -234,7 +258,8 @@ class large_number {
      * operator overload to increment
      **/
     template <class T>
-    large_number &operator*=(const T n) {
+    large_number &operator*=(const T n)
+    {
         static_assert(std::is_integral<T>::value,
                       "Must be integer addition unsigned integer types.");
         this->multiply(n);
@@ -244,7 +269,8 @@ class large_number {
     /**
      * returns i^th digit as an ASCII character
      **/
-    const char digit_char(size_t i) const {
+    const char digit_char(size_t i) const
+    {
         return _digits[num_digits() - i - 1] + '0';
     }
 
@@ -254,7 +280,8 @@ class large_number {
      * store the result in the same large number
      **/
     template <class T>
-    void multiply(const T n) {
+    void multiply(const T n)
+    {
         static_assert(std::is_integral<T>::value,
                       "Can only have integer types.");
         // assert(!(std::is_signed<T>::value)); //, "Implemented only for
@@ -262,19 +289,24 @@ class large_number {
 
         size_t i;
         uint64_t carry = 0, temp;
-        for (i = 0; i < this->num_digits(); i++) {
+        for (i = 0; i < this->num_digits(); i++)
+        {
             temp = (*this)[i] * n;
             temp += carry;
-            if (temp < 10) {
+            if (temp < 10)
+            {
                 carry = 0;
-            } else {
+            }
+            else
+            {
                 carry = temp / 10;
                 temp = temp % 10;
             }
             (*this)[i] = temp;
         }
 
-        while (carry != 0) {
+        while (carry != 0)
+        {
             this->add_digit(carry % 10);
             carry /= 10;
         }
diff --git a/math/modular_inverse_fermat_little_theorem.cpp b/math/modular_inverse_fermat_little_theorem.cpp
index 7550e14bf..6895cafbb 100644
--- a/math/modular_inverse_fermat_little_theorem.cpp
+++ b/math/modular_inverse_fermat_little_theorem.cpp
@@ -49,11 +49,14 @@
 /** Recursive function to calculate exponent in \f$O(\log n)\f$ using binary
  * exponent.
  */
-int64_t binExpo(int64_t a, int64_t b, int64_t m) {
+int64_t binExpo(int64_t a, int64_t b, int64_t m)
+{
     a %= m;
     int64_t res = 1;
-    while (b > 0) {
-        if (b % 2) {
+    while (b > 0)
+    {
+        if (b % 2)
+        {
             res = res * a % m;
         }
         a = a * a % m;
@@ -65,12 +68,18 @@ int64_t binExpo(int64_t a, int64_t b, int64_t m) {
 
 /** Prime check in \f$O(\sqrt{m})\f$ time.
  */
-bool isPrime(int64_t m) {
-    if (m <= 1) {
+bool isPrime(int64_t m)
+{
+    if (m <= 1)
+    {
         return false;
-    } else {
-        for (int64_t i = 2; i * i <= m; i++) {
-            if (m % i == 0) {
+    }
+    else
+    {
+        for (int64_t i = 2; i * i <= m; i++)
+        {
+            if (m % i == 0)
+            {
                 return false;
             }
         }
@@ -81,17 +90,21 @@ bool isPrime(int64_t m) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     int64_t a, m;
     // Take input of  a and m.
     std::cout << "Computing ((a^(-1))%(m)) using Fermat's Little Theorem";
     std::cout << std::endl << std::endl;
     std::cout << "Give input 'a' and 'm' space separated : ";
     std::cin >> a >> m;
-    if (isPrime(m)) {
+    if (isPrime(m))
+    {
         std::cout << "The modular inverse of a with mod m is (a^(m-2)) : ";
         std::cout << binExpo(a, m - 2, m) << std::endl;
-    } else {
+    }
+    else
+    {
         std::cout << "m must be a prime number.";
         std::cout << std::endl;
     }
diff --git a/math/number_of_positive_divisors.cpp b/math/number_of_positive_divisors.cpp
index f157f7b41..beb459943 100644
--- a/math/number_of_positive_divisors.cpp
+++ b/math/number_of_positive_divisors.cpp
@@ -31,25 +31,31 @@ respectively.
 /**
  * Algorithm
  */
-int number_of_positive_divisors(int n) {
+int number_of_positive_divisors(int n)
+{
     std::vector<int> prime_exponent_count;
-    for (int i = 2; i * i <= n; i++) {
+    for (int i = 2; i * i <= n; i++)
+    {
         int prime_count = 0;
-        while (n % i == 0) {
+        while (n % i == 0)
+        {
             prime_count += 1;
             n /= i;
         }
-        if (prime_count != 0) {
+        if (prime_count != 0)
+        {
             prime_exponent_count.push_back(prime_count);
         }
     }
-    if (n > 1) {
+    if (n > 1)
+    {
         prime_exponent_count.push_back(1);
     }
 
     int divisors_count = 1;
 
-    for (int i = 0; i < prime_exponent_count.size(); i++) {
+    for (int i = 0; i < prime_exponent_count.size(); i++)
+    {
         divisors_count = divisors_count * (prime_exponent_count[i] + 1);
     }
 
@@ -59,15 +65,20 @@ int number_of_positive_divisors(int n) {
 /**
  * Main function
  */
-int main() {
+int main()
+{
     int n;
     std::cin >> n;
-    if (n < 0) {
+    if (n < 0)
+    {
         n = -n;
     }
-    if (n == 0) {
+    if (n == 0)
+    {
         std::cout << "All non-zero numbers are divisors of 0 !" << std::endl;
-    } else {
+    }
+    else
+    {
         std::cout << "Number of positive divisors is : ";
         std::cout << number_of_positive_divisors(n) << std::endl;
     }
diff --git a/math/power_for_huge_numbers.cpp b/math/power_for_huge_numbers.cpp
index 301767d66..1f969f89d 100644
--- a/math/power_for_huge_numbers.cpp
+++ b/math/power_for_huge_numbers.cpp
@@ -22,13 +22,15 @@
  * @param res large number representation using array
  * @param res_size number of digits in `res`
  */
-int multiply(int x, int res[], int res_size) {
+int multiply(int x, int res[], int res_size)
+{
     // Initialize carry
     int carry = 0;
 
     // One by one multiply n with
     // individual digits of res[]
-    for (int i = 0; i < res_size; i++) {
+    for (int i = 0; i < res_size; i++)
+    {
         int prod = res[i] * x + carry;
 
         // Store last digit of
@@ -41,7 +43,8 @@ int multiply(int x, int res[], int res_size) {
 
     // Put carry in res and
     // increase result size
-    while (carry) {
+    while (carry)
+    {
         res[res_size] = carry % 10;
         carry = carry / 10;
         res_size++;
@@ -53,9 +56,11 @@ int multiply(int x, int res[], int res_size) {
  * @param x base
  * @param n exponent
  */
-void power(int x, int n) {
+void power(int x, int n)
+{
     // printing value "1" for power = 0
-    if (n == 0) {
+    if (n == 0)
+    {
         std::cout << "1";
         return;
     }
@@ -65,7 +70,8 @@ void power(int x, int n) {
     int temp = x;
 
     // Initialize result
-    while (temp != 0) {
+    while (temp != 0)
+    {
         res[res_size++] = temp % 10;
         temp = temp / 10;
     }
@@ -79,7 +85,8 @@ void power(int x, int n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int exponent, base;
     std::cout << "Enter base ";
     std::cin >> base;
diff --git a/math/prime_factorization.cpp b/math/prime_factorization.cpp
index d0e05cb4c..c650497e2 100644
--- a/math/prime_factorization.cpp
+++ b/math/prime_factorization.cpp
@@ -20,44 +20,55 @@ std::vector<std::pair<int, int>> factors;
 
 /** Calculating prime number upto a given range
  */
-void SieveOfEratosthenes(int N) {
+void SieveOfEratosthenes(int N)
+{
     // initializes the array isprime
     memset(isprime, true, sizeof isprime);
 
-    for (int i = 2; i <= N; i++) {
-        if (isprime[i]) {
+    for (int i = 2; i <= N; i++)
+    {
+        if (isprime[i])
+        {
             for (int j = 2 * i; j <= N; j += i) isprime[j] = false;
         }
     }
 
-    for (int i = 2; i <= N; i++) {
-        if (isprime[i]) prime_numbers.push_back(i);
+    for (int i = 2; i <= N; i++)
+    {
+        if (isprime[i])
+            prime_numbers.push_back(i);
     }
 }
 
 /** Prime factorization of a number */
-void prime_factorization(int num) {
+void prime_factorization(int num)
+{
     int number = num;
 
-    for (int i = 0; prime_numbers[i] <= num; i++) {
+    for (int i = 0; prime_numbers[i] <= num; i++)
+    {
         int count = 0;
 
         // termination condition
-        if (number == 1) {
+        if (number == 1)
+        {
             break;
         }
 
-        while (number % prime_numbers[i] == 0) {
+        while (number % prime_numbers[i] == 0)
+        {
             count++;
             number = number / prime_numbers[i];
         }
 
-        if (count) factors.push_back(std::make_pair(prime_numbers[i], count));
+        if (count)
+            factors.push_back(std::make_pair(prime_numbers[i], count));
     }
 }
 
 /** Main program */
-int main() {
+int main()
+{
     int num;
     std::cout << "\t\tComputes the prime factorization\n\n";
     std::cout << "Type in a number: ";
@@ -68,7 +79,8 @@ int main() {
     prime_factorization(num);
 
     // Prime factors with their powers in the given number in new line
-    for (auto it : factors) {
+    for (auto it : factors)
+    {
         std::cout << it.first << " " << it.second << std::endl;
     }
 
diff --git a/math/prime_numbers.cpp b/math/prime_numbers.cpp
index 4dd54f136..b3a52a104 100644
--- a/math/prime_numbers.cpp
+++ b/math/prime_numbers.cpp
@@ -9,12 +9,15 @@
 /** Generate an increasingly large number of primes
  * and store in a list
  */
-std::vector<int> primes(int max) {
+std::vector<int> primes(int max)
+{
     max++;
     std::vector<int> res;
     std::vector<bool> numbers(max, false);
-    for (int i = 2; i < max; i++) {
-        if (!numbers[i]) {
+    for (int i = 2; i < max; i++)
+    {
+        if (!numbers[i])
+        {
             for (int j = i; j < max; j += i) numbers[j] = true;
             res.push_back(i);
         }
@@ -23,7 +26,8 @@ std::vector<int> primes(int max) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     std::cout << "Calculate primes up to:\n>> ";
     int n;
     std::cin >> n;
diff --git a/math/primes_up_to_billion.cpp b/math/primes_up_to_billion.cpp
index 4fb79a15e..6c02b9089 100644
--- a/math/primes_up_to_billion.cpp
+++ b/math/primes_up_to_billion.cpp
@@ -10,12 +10,15 @@
 char prime[100000000];
 
 /** Perform Sieve algorithm */
-void Sieve(int64_t n) {
+void Sieve(int64_t n)
+{
     memset(prime, '1', sizeof(prime));  // intitize '1' to every index
     prime[0] = '0';                     // 0 is not prime
     prime[1] = '0';                     // 1 is not prime
-    for (int p = 2; p * p <= n; p++) {
-        if (prime[p] == '1') {
+    for (int p = 2; p * p <= n; p++)
+    {
+        if (prime[p] == '1')
+        {
             for (int i = p * p; i <= n; i += p)
                 prime[i] = '0';  // set all multiples of p to false
         }
@@ -23,7 +26,8 @@ void Sieve(int64_t n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     Sieve(100000000);
     int64_t n;
     std::cin >> n;  // 10006187
diff --git a/math/sieve_of_eratosthenes.cpp b/math/sieve_of_eratosthenes.cpp
index d8fa70531..90ad8bc40 100644
--- a/math/sieve_of_eratosthenes.cpp
+++ b/math/sieve_of_eratosthenes.cpp
@@ -22,12 +22,16 @@ bool isprime[MAX];
  * This is the function that finds the primes and eliminates
  * the multiples.
  */
-void sieve(uint32_t N) {
+void sieve(uint32_t N)
+{
     isprime[0] = false;
     isprime[1] = false;
-    for (uint32_t i = 2; i <= N; i++) {
-        if (isprime[i]) {
-            for (uint32_t j = (i << 1); j <= N; j += i) {
+    for (uint32_t i = 2; i <= N; i++)
+    {
+        if (isprime[i])
+        {
+            for (uint32_t j = (i << 1); j <= N; j += i)
+            {
                 isprime[j] = false;
             }
         }
@@ -37,9 +41,12 @@ void sieve(uint32_t N) {
 /**
  * This function prints out the primes to STDOUT
  */
-void print(uint32_t N) {
-    for (uint32_t i = 1; i <= N; i++) {
-        if (isprime[i]) {
+void print(uint32_t N)
+{
+    for (uint32_t i = 1; i <= N; i++)
+    {
+        if (isprime[i])
+        {
             std::cout << i << ' ';
         }
     }
@@ -49,14 +56,17 @@ void print(uint32_t N) {
 /**
  * Initialize the array
  */
-void init() {
-    for (uint32_t i = 1; i < MAX; i++) {
+void init()
+{
+    for (uint32_t i = 1; i < MAX; i++)
+    {
         isprime[i] = true;
     }
 }
 
 /** main function */
-int main() {
+int main()
+{
     uint32_t N = 100;
     init();
     sieve(N);
diff --git a/math/sqrt_double.cpp b/math/sqrt_double.cpp
index 1521b500a..ffc83998a 100644
--- a/math/sqrt_double.cpp
+++ b/math/sqrt_double.cpp
@@ -13,8 +13,10 @@
 /** Bisection method implemented for the function \f$x^2-a=0\f$
  * whose roots are \f$\pm\sqrt{a}\f$ and only the positive root is returned.
  */
-double Sqrt(double a) {
-    if (a > 0 && a < 1) {
+double Sqrt(double a)
+{
+    if (a > 0 && a < 1)
+    {
         return 1 / Sqrt(1 / a);
     }
     double l = 0, r = a;
@@ -24,12 +26,17 @@ double Sqrt(double a) {
     double epsilon = 1e-12;
     */
     double epsilon = 1e-12;
-    while (l <= r) {
+    while (l <= r)
+    {
         double mid = (l + r) / 2;
-        if (mid * mid > a) {
+        if (mid * mid > a)
+        {
             r = mid;
-        } else {
-            if (a - mid * mid < epsilon) {
+        }
+        else
+        {
+            if (a - mid * mid < epsilon)
+            {
                 return mid;
             }
             l = mid;
@@ -39,7 +46,8 @@ double Sqrt(double a) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     double n{};
     std::cin >> n;
     assert(n >= 0);
diff --git a/math/string_fibonacci.cpp b/math/string_fibonacci.cpp
index eb9b6d7e1..401b04d2d 100644
--- a/math/string_fibonacci.cpp
+++ b/math/string_fibonacci.cpp
@@ -21,41 +21,50 @@
  * \param [in] b second number in string to add
  * \returns sum as a std::string
  */
-std::string add(std::string a, std::string b) {
+std::string add(std::string a, std::string b)
+{
     std::string temp = "";
 
     // carry flag
     int carry = 0;
 
     // fills up with zeros
-    while (a.length() < b.length()) {
+    while (a.length() < b.length())
+    {
         a = "0" + a;
     }
 
     // fills up with zeros
-    while (b.length() < a.length()) {
+    while (b.length() < a.length())
+    {
         b = "0" + b;
     }
 
     // adds the numbers a and b
-    for (int i = a.length() - 1; i >= 0; i--) {
+    for (int i = a.length() - 1; i >= 0; i--)
+    {
         char val = static_cast<char>(((a[i] - 48) + (b[i] - 48)) + 48 + carry);
-        if (val > 57) {
+        if (val > 57)
+        {
             carry = 1;
             val -= 10;
-        } else {
+        }
+        else
+        {
             carry = 0;
         }
         temp = val + temp;
     }
 
     // processes the carry flag
-    if (carry == 1) {
+    if (carry == 1)
+    {
         temp = "1" + temp;
     }
 
     // removes leading zeros.
-    while (temp[0] == '0' && temp.length() > 1) {
+    while (temp[0] == '0' && temp.length() > 1)
+    {
         temp = temp.substr(1);
     }
 
@@ -65,11 +74,13 @@ std::string add(std::string a, std::string b) {
 /** Fibonacci iterator
  * \param [in] n n^th Fibonacci number
  */
-void fib_Accurate(uint64_t n) {
+void fib_Accurate(uint64_t n)
+{
     std::string tmp = "";
     std::string fibMinus1 = "1";
     std::string fibMinus2 = "0";
-    for (uint64_t i = 0; i < n; i++) {
+    for (uint64_t i = 0; i < n; i++)
+    {
         tmp = add(fibMinus1, fibMinus2);
         fibMinus2 = fibMinus1;
         fibMinus1 = tmp;
@@ -78,7 +89,8 @@ void fib_Accurate(uint64_t n) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     int n;
     std::cout << "Enter whatever number N you want to find the fibonacci of\n";
     std::cin >> n;
diff --git a/operations_on_datastructures/array_left_rotation.cpp b/operations_on_datastructures/array_left_rotation.cpp
index 9eb5d4e50..444738360 100644
--- a/operations_on_datastructures/array_left_rotation.cpp
+++ b/operations_on_datastructures/array_left_rotation.cpp
@@ -2,38 +2,38 @@
 using namespace std;
 int main()
 {
-	int n, k;
-	cout << "Enter size of array=\t";
-	cin >> n;
-	cout << "Enter Number of indeces u want to rotate the array to left=\t";
-	cin >> k;
-	int a[n];
-	cout << "Enter  elements of array=\t";
-	for (int i = 0; i < n; i++)
-	{
-		cin >> a[i];
-	}
-	int temp = 0;
-	for (int i = 0; i < k; i++)
-	{
-		temp = a[0];
-		for (int j = 0; j < n; j++)
-		{
-			if (j == n - 1)
-			{
-				a[n - 1] = temp;
-			}
-			else
-			{
-				a[j] = a[j + 1];
-			}
-		}
-	}
-	cout << "Your rotated array is=\t";
-	for (int j = 0; j < n; j++)
-	{
-		cout << a[j] << " ";
-	}
-	getchar();
-	return 0;
+    int n, k;
+    cout << "Enter size of array=\t";
+    cin >> n;
+    cout << "Enter Number of indeces u want to rotate the array to left=\t";
+    cin >> k;
+    int a[n];
+    cout << "Enter  elements of array=\t";
+    for (int i = 0; i < n; i++)
+    {
+        cin >> a[i];
+    }
+    int temp = 0;
+    for (int i = 0; i < k; i++)
+    {
+        temp = a[0];
+        for (int j = 0; j < n; j++)
+        {
+            if (j == n - 1)
+            {
+                a[n - 1] = temp;
+            }
+            else
+            {
+                a[j] = a[j + 1];
+            }
+        }
+    }
+    cout << "Your rotated array is=\t";
+    for (int j = 0; j < n; j++)
+    {
+        cout << a[j] << " ";
+    }
+    getchar();
+    return 0;
 }
diff --git a/operations_on_datastructures/array_right_rotation.cpp b/operations_on_datastructures/array_right_rotation.cpp
index 81875766c..5077d2d74 100644
--- a/operations_on_datastructures/array_right_rotation.cpp
+++ b/operations_on_datastructures/array_right_rotation.cpp
@@ -9,8 +9,7 @@ int main()
     cin >> k;
     int a[n];
     cout << "Enter elements of array=\t";
-    for (int i = 0; i < n; i++)
-        cin >> a[i];
+    for (int i = 0; i < n; i++) cin >> a[i];
     int temp = 0;
     for (int i = 0; i < k; i++)
     {
diff --git a/operations_on_datastructures/circular_linked_list.cpp b/operations_on_datastructures/circular_linked_list.cpp
index d360f6cd7..2fddd3b7b 100644
--- a/operations_on_datastructures/circular_linked_list.cpp
+++ b/operations_on_datastructures/circular_linked_list.cpp
@@ -3,112 +3,112 @@ using namespace std;
 
 struct node
 {
-	int val;
-	node *next;
+    int val;
+    node *next;
 };
 
 node *start;
 
 void insert(int x)
 {
-	node *t = start;
+    node *t = start;
 
-	if (start != NULL)
-	{
-		while (t->next != start)
-		{
-			t = t->next;
-		}
-		node *n = new node;
-		t->next = n;
-		n->val = x;
-		n->next = start;
-	}
-	else
-	{
-		node *n = new node;
-		n->val = x;
-		start = n;
-		n->next = start;
-	}
+    if (start != NULL)
+    {
+        while (t->next != start)
+        {
+            t = t->next;
+        }
+        node *n = new node;
+        t->next = n;
+        n->val = x;
+        n->next = start;
+    }
+    else
+    {
+        node *n = new node;
+        n->val = x;
+        start = n;
+        n->next = start;
+    }
 }
 
 void remove(int x)
 {
-	node *t = start;
-	node *p;
-	while (t->val != x)
-	{
-		p = t;
-		t = t->next;
-	}
-	p->next = t->next;
-	delete t;
+    node *t = start;
+    node *p;
+    while (t->val != x)
+    {
+        p = t;
+        t = t->next;
+    }
+    p->next = t->next;
+    delete t;
 }
 
 void search(int x)
 {
-	node *t = start;
-	int found = 0;
-	while (t->next != start)
-	{
-		if (t->val == x)
-		{
-			cout << "\nFound";
-			found = 1;
-			break;
-		}
-		t = t->next;
-	}
-	if (found == 0)
-	{
-		cout << "\nNot Found";
-	}
+    node *t = start;
+    int found = 0;
+    while (t->next != start)
+    {
+        if (t->val == x)
+        {
+            cout << "\nFound";
+            found = 1;
+            break;
+        }
+        t = t->next;
+    }
+    if (found == 0)
+    {
+        cout << "\nNot Found";
+    }
 }
 
 void show()
 {
-	node *t = start;
-	do
-	{
-		cout << t->val << "\t";
-		t = t->next;
-	} while (t != start);
+    node *t = start;
+    do
+    {
+        cout << t->val << "\t";
+        t = t->next;
+    } while (t != start);
 }
 
 int main()
 {
-	int choice, x;
-	do
-	{
-		cout << "\n1. Insert";
-		cout << "\n2. Delete";
-		cout << "\n3. Search";
-		cout << "\n4. Print";
-		cout << "\n\nEnter you choice : ";
-		cin >> choice;
-		switch (choice)
-		{
-		case 1:
-			cout << "\nEnter the element to be inserted : ";
-			cin >> x;
-			insert(x);
-			break;
-		case 2:
-			cout << "\nEnter the element to be removed : ";
-			cin >> x;
-			remove(x);
-			break;
-		case 3:
-			cout << "\nEnter the element to be searched : ";
-			cin >> x;
-			search(x);
-			break;
-		case 4:
-			show();
-			break;
-		}
-	} while (choice != 0);
+    int choice, x;
+    do
+    {
+        cout << "\n1. Insert";
+        cout << "\n2. Delete";
+        cout << "\n3. Search";
+        cout << "\n4. Print";
+        cout << "\n\nEnter you choice : ";
+        cin >> choice;
+        switch (choice)
+        {
+        case 1:
+            cout << "\nEnter the element to be inserted : ";
+            cin >> x;
+            insert(x);
+            break;
+        case 2:
+            cout << "\nEnter the element to be removed : ";
+            cin >> x;
+            remove(x);
+            break;
+        case 3:
+            cout << "\nEnter the element to be searched : ";
+            cin >> x;
+            search(x);
+            break;
+        case 4:
+            show();
+            break;
+        }
+    } while (choice != 0);
 
-	return 0;
+    return 0;
 }
diff --git a/operations_on_datastructures/circular_queue_using_array.cpp b/operations_on_datastructures/circular_queue_using_array.cpp
index 36d7e22c3..cf6e39dd5 100644
--- a/operations_on_datastructures/circular_queue_using_array.cpp
+++ b/operations_on_datastructures/circular_queue_using_array.cpp
@@ -8,67 +8,66 @@ int count = 0;
 
 void Enque(int x)
 {
-	if (count == 10)
-	{
-		cout << "\nOverflow";
-	}
-	else
-	{
-		queue[rear] = x;
-		rear = (rear + 1) % 10;
-		count++;
-	}
+    if (count == 10)
+    {
+        cout << "\nOverflow";
+    }
+    else
+    {
+        queue[rear] = x;
+        rear = (rear + 1) % 10;
+        count++;
+    }
 }
 
 void Deque()
 {
-	if (front == rear)
-	{
-		cout << "\nUnderflow";
-	}
+    if (front == rear)
+    {
+        cout << "\nUnderflow";
+    }
 
-	else
-	{
-		cout << "\n"
-			 << queue[front] << " deleted";
-		front = (front + 1) % 10;
-		count--;
-	}
+    else
+    {
+        cout << "\n" << queue[front] << " deleted";
+        front = (front + 1) % 10;
+        count--;
+    }
 }
 
 void show()
 {
-	for (int i = 0; i < count; i++)
-	{
-		cout << queue[(i + front) % 10] << "\t";
-	}
+    for (int i = 0; i < count; i++)
+    {
+        cout << queue[(i + front) % 10] << "\t";
+    }
 }
 
 int main()
 {
-	int ch, x;
-	do
-	{
-		cout << "\n1. Enque";
-		cout << "\n2. Deque";
-		cout << "\n3. Print";
-		cout << "\nEnter Your Choice : ";
-		cin >> ch;
-		if (ch == 1)
-		{
-			cout << "\nInsert : ";
-			cin >> x;
-			Enque(x);
-		}
-		else if (ch == 2)
-		{
-			Deque();
-		}
-		else if (ch == 3)
-		{
-			show();
-		}
-	} while (ch != 0);
+    int ch, x;
+    do
+    {
+        cout << "\n1. Enque";
+        cout << "\n2. Deque";
+        cout << "\n3. Print";
+        cout << "\nEnter Your Choice : ";
+        cin >> ch;
+        if (ch == 1)
+        {
+            cout << "\nInsert : ";
+            cin >> x;
+            Enque(x);
+        }
+        else if (ch == 2)
+        {
+            Deque();
+        }
+        else if (ch == 3)
+        {
+            show();
+        }
+    } while (ch != 0);
 
-	return 0;
+    return 0;
 }
diff --git a/operations_on_datastructures/get_size_of_linked_list.cpp b/operations_on_datastructures/get_size_of_linked_list.cpp
index 84f8db07f..0f22967c2 100644
--- a/operations_on_datastructures/get_size_of_linked_list.cpp
+++ b/operations_on_datastructures/get_size_of_linked_list.cpp
@@ -1,6 +1,7 @@
 #include <iostream>
 
-class Node {
+class Node
+{
  public:
     int val;
     Node *next;
@@ -8,19 +9,23 @@ class Node {
     Node(int v, Node *n) : val(v), next(n) {}  // Default constructor for Node
 };
 
-int getSize(Node *root) {
-    if (root == NULL) {
+int getSize(Node *root)
+{
+    if (root == NULL)
+    {
         return 0;
     }
     // Each node will return 1 so the total adds up to be the size
     return 1 + getSize(root->next);
 }
 
-int main() {
+int main()
+{
     Node *myList = new Node(0, NULL);  // Initializes the LinkedList
     Node *temp = myList;
     // Creates a linked lists of total size 10, numbered 1 - 10
-    for (int i = 1; i < 10; i++) {
+    for (int i = 1; i < 10; i++)
+    {
         temp->next = new Node(i, NULL);
         temp = temp->next;
     }
diff --git a/operations_on_datastructures/intersection_of_2_arrays.cpp b/operations_on_datastructures/intersection_of_2_arrays.cpp
index 05652811f..df83c9f21 100644
--- a/operations_on_datastructures/intersection_of_2_arrays.cpp
+++ b/operations_on_datastructures/intersection_of_2_arrays.cpp
@@ -1,31 +1,29 @@
 #include <iostream>
 int main()
 {
-  int i, j, m, n;
-  cout << "Enter size of array 1:";
-  cin >> m;
-  cout << "Enter size of array 2:";
-  cin >> n;
-  int a[m];
-  int b[n];
-  cout << "Enter elements of array 1:";
-  for (i = 0; i < m; i++)
-    cin >> a[i];
-  for (i = 0; i < n; i++)
-    cin >> b[i];
-  i = 0;
-  j = 0;
-  while ((i < m) && (j < n))
-  {
-    if (a[i] < b[j])
-      i++;
-    else if (a[i] > b[j])
-      j++;
-    else
+    int i, j, m, n;
+    cout << "Enter size of array 1:";
+    cin >> m;
+    cout << "Enter size of array 2:";
+    cin >> n;
+    int a[m];
+    int b[n];
+    cout << "Enter elements of array 1:";
+    for (i = 0; i < m; i++) cin >> a[i];
+    for (i = 0; i < n; i++) cin >> b[i];
+    i = 0;
+    j = 0;
+    while ((i < m) && (j < n))
     {
-      cout << a[i++] << " ";
-      j++;
+        if (a[i] < b[j])
+            i++;
+        else if (a[i] > b[j])
+            j++;
+        else
+        {
+            cout << a[i++] << " ";
+            j++;
+        }
     }
-  }
-  return 0;
+    return 0;
 }
diff --git a/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp b/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
index 0908080cc..4fe6d2915 100644
--- a/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
+++ b/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
@@ -3,74 +3,74 @@ using namespace std;
 
 struct node
 {
-	int val;
-	node *next;
+    int val;
+    node *next;
 };
 
 node *start;
 
 void insert(int x)
 {
-	node *t = start;
-	if (start != NULL)
-	{
-		while (t->next != NULL)
-		{
-			t = t->next;
-		}
-		node *n = new node;
-		t->next = n;
-		n->val = x;
-		n->next = NULL;
-	}
-	else
-	{
-		node *n = new node;
-		n->val = x;
-		n->next = NULL;
-		start = n;
-	}
+    node *t = start;
+    if (start != NULL)
+    {
+        while (t->next != NULL)
+        {
+            t = t->next;
+        }
+        node *n = new node;
+        t->next = n;
+        n->val = x;
+        n->next = NULL;
+    }
+    else
+    {
+        node *n = new node;
+        n->val = x;
+        n->next = NULL;
+        start = n;
+    }
 }
 
 void reverse(node *p, node *q)
 {
-	if (q->next == NULL)
-	{
-		q->next = p;
-		p->next = NULL;
-		start = q;
-		return;
-	}
-	else
-	{
-		reverse(q, q->next);
-		q->next = p;
-		p->next = NULL;
-	}
+    if (q->next == NULL)
+    {
+        q->next = p;
+        p->next = NULL;
+        start = q;
+        return;
+    }
+    else
+    {
+        reverse(q, q->next);
+        q->next = p;
+        p->next = NULL;
+    }
 }
 
 void show()
 {
-	node *t = start;
-	while (t != NULL)
-	{
-		cout << t->val << "\t";
-		t = t->next;
-	}
+    node *t = start;
+    while (t != NULL)
+    {
+        cout << t->val << "\t";
+        t = t->next;
+    }
 }
 
 int main()
 {
-	insert(1);
-	insert(2);
-	insert(3);
-	insert(4);
-	insert(5);
-	insert(6);
+    insert(1);
+    insert(2);
+    insert(3);
+    insert(4);
+    insert(5);
+    insert(6);
 
-	reverse(start, start->next);
+    reverse(start, start->next);
 
-	show();
+    show();
 
-	return 0;
+    return 0;
 }
diff --git a/operations_on_datastructures/selectionsortlinkedlist.cpp b/operations_on_datastructures/selectionsortlinkedlist.cpp
index 52363ceff..550928d01 100644
--- a/operations_on_datastructures/selectionsortlinkedlist.cpp
+++ b/operations_on_datastructures/selectionsortlinkedlist.cpp
@@ -1,10 +1,10 @@
 #include <iostream>
 using namespace std;
 
-//node defined
+// node defined
 class node
 {
-public:
+ public:
     int data;
     node *link;
     node(int d)
@@ -14,7 +14,7 @@ public:
     }
 };
 
-//printing the linked list
+// printing the linked list
 void print(node *head)
 {
     node *current = head;
@@ -26,7 +26,7 @@ void print(node *head)
     cout << endl;
 }
 
-//creating the linked list with 'n' nodes
+// creating the linked list with 'n' nodes
 node *createlist(int n)
 {
     node *head = NULL;
@@ -50,51 +50,71 @@ node *createlist(int n)
     return head;
 }
 
-//performing selection sort on the linked list in an iterative manner
+// performing selection sort on the linked list in an iterative manner
 void my_selection_sort_linked_list(node *&head)
 {
-    node *min = head;          //throughout the algorithm 'min' is used to denote the node with min value out of all the nodes left for scanning
-                               //while scanning if we find a node 'X' with value lesser than min,
-                               //then we update the pointers in such a way that 'X' becomes the predecessor of 'min'
-    node *current = min->link; // 'current' refers to the current node we are scanning
-    node *previous = min;      //'previous' refers to the node that is previous to the current node
-    node *temp = NULL;         // 'temp' in this algo is used to point to the last node of the sorted part of the linked list.
-                               //eg. If at any time instance the state of the linked list is suppose 1->2->5->3->8->NULL
-                               //then, we see that "1->2" is the sorted part of the LL, and therefore temp will be pointing to the last node of the sorted part,i.e,'2'
-                               //We keep on arranging the Linked list in such a way that after each iteration the node with 'min' value is placed at its correct position.
-                               //Eg. Let suppose initially we have 5->4->1->3->2->NULL
-                               //After 1st iteration : 1->4->5->3->2->NULL and so on
+    node *min = head;  // throughout the algorithm 'min' is used to denote the
+                       // node with min value out of all the nodes left for
+                       // scanning while scanning if we find a node 'X' with
+                       // value lesser than min, then we update the pointers in
+                       // such a way that 'X' becomes the predecessor of 'min'
+    node *current =
+        min->link;  // 'current' refers to the current node we are scanning
+    node *previous = min;  //'previous' refers to the node that is previous to
+                           //the current node
+    node *temp =
+        NULL;  // 'temp' in this algo is used to point to the last node of the
+               // sorted part of the linked list.
+               // eg. If at any time instance the state of the linked list is
+               // suppose 1->2->5->3->8->NULL then, we see that "1->2" is the
+               // sorted part of the LL, and therefore temp will be pointing to
+               // the last node of the sorted part,i.e,'2' We keep on arranging
+               // the Linked list in such a way that after each iteration the
+               // node with 'min' value is placed at its correct position. Eg.
+               // Let suppose initially we have 5->4->1->3->2->NULL After 1st
+               // iteration : 1->4->5->3->2->NULL and so on
 
-    while (min->link != NULL) //so that all the nodes are scanned or until there exists a node
+    while (
+        min->link !=
+        NULL)  // so that all the nodes are scanned or until there exists a node
     {
-        //pick the first node from the unsorted part and assume that it is the minimum and then start scanning from the next node
+        // pick the first node from the unsorted part and assume that it is the
+        // minimum and then start scanning from the next node
 
-        while (current != NULL) //suppose you choose the min node to be X, then scan starts from the (X+1)th node until its NULL. current = (X+1)th node and min = X
+        while (current != NULL)  // suppose you choose the min node to be X,
+                                 // then scan starts from the (X+1)th node until
+                                 // its NULL. current = (X+1)th node and min = X
         {
-            if (current->data < min->data) //if the current node is smaller than the presumed node 'min'
+            if (current->data < min->data)  // if the current node is smaller
+                                            // than the presumed node 'min'
             {
-                if (temp == NULL) //temp stays null for the first iteration, therefore it symbolizes that we are scanning for the first time
+                if (temp == NULL)  // temp stays null for the first iteration,
+                                   // therefore it symbolizes that we are
+                                   // scanning for the first time
                 {
-                    if (previous == min) //if the 'previous' is pointing to the 'min' node
+                    if (previous ==
+                        min)  // if the 'previous' is pointing to the 'min' node
                     {
-                        //Update the pointers
-                        head = current; //update the head pointer with the current node
+                        // Update the pointers
+                        head = current;  // update the head pointer with the
+                                         // current node
                         min->link = current->link;
                         current->link = previous;
                         min = current;
                         current = previous->link;
                     }
-                    else //if the 'previous' is not pointing to the 'min' node
+                    else  // if the 'previous' is not pointing to the 'min' node
                     {
-                        //Update the pointers
-                        head = current; //update the head pointer with the current node
+                        // Update the pointers
+                        head = current;  // update the head pointer with the
+                                         // current node
                         previous->link = current->link;
                         current->link = min;
                         min = current;
                         current = previous->link;
                     }
                 }
-                else //if 'temp' is not NULL, i.e., its not the 1st iteration
+                else  // if 'temp' is not NULL, i.e., its not the 1st iteration
                 {
                     temp->link = current;
                     previous->link = current->link;
@@ -103,15 +123,17 @@ void my_selection_sort_linked_list(node *&head)
                     current = previous->link;
                 }
             }
-            else //if the current node is greater than min, just move the previous and the current pointer a step further
+            else  // if the current node is greater than min, just move the
+                  // previous and the current pointer a step further
             {
                 previous = previous->link;
                 current = current->link;
             }
         }
 
-        //update the pointers. Set 'temp' to the last node in the sorted part. Make 'min' move a step further so that 'min' points to the 1st node of the unsorted part
-        //start the iteration again
+        // update the pointers. Set 'temp' to the last node in the sorted part.
+        // Make 'min' move a step further so that 'min' points to the 1st node of
+        // the unsorted part start the iteration again
         temp = min;
         min = min->link;
         previous = min;
@@ -145,15 +167,16 @@ int main()
 {
     node *head = NULL;
     int n;
-    cout << "enter the no. of nodes : "; //taking input from user about the number of nodes in linked list
+    cout << "enter the no. of nodes : ";  // taking input from user about the
+                                          // number of nodes in linked list
     cin >> n;
     if (n == 0)
         return 0;
-    head = createlist(n); //creating the list
+    head = createlist(n);  // creating the list
     cout << "original list is : ";
-    print(head);                         //printing the original linked list
-    my_selection_sort_linked_list(head); //applying selection sort
+    print(head);                          // printing the original linked list
+    my_selection_sort_linked_list(head);  // applying selection sort
     cout << "sorted list is : ";
-    print(head); //printing the sorted linked list
+    print(head);  // printing the sorted linked list
     return 0;
 }
\ No newline at end of file
diff --git a/operations_on_datastructures/union_of_2_arrays.cpp b/operations_on_datastructures/union_of_2_arrays.cpp
index aaaeb8378..45845f341 100644
--- a/operations_on_datastructures/union_of_2_arrays.cpp
+++ b/operations_on_datastructures/union_of_2_arrays.cpp
@@ -1,34 +1,30 @@
 #include <iostream>
 int main()
 {
-  int m, n, i = 0, j = 0;
-  cout << "Enter size of both arrays:";
-  cin >> m >> n;
-  int a[m];
-  int b[n];
-  cout << "Enter elements of array 1:";
-  for (i = 0; i < m; i++)
-    cin >> a[i];
-  cout << "Enter elements of array 2:";
-  for (i = 0; i < n; i++)
-    cin >> b[i];
-  i = 0;
-  j = 0;
-  while ((i < m) && (j < n))
-  {
-    if (a[i] < b[j])
-      cout << a[i++] << " ";
-    else if (a[i] > b[j])
-      cout << b[j++] << " ";
-    else
+    int m, n, i = 0, j = 0;
+    cout << "Enter size of both arrays:";
+    cin >> m >> n;
+    int a[m];
+    int b[n];
+    cout << "Enter elements of array 1:";
+    for (i = 0; i < m; i++) cin >> a[i];
+    cout << "Enter elements of array 2:";
+    for (i = 0; i < n; i++) cin >> b[i];
+    i = 0;
+    j = 0;
+    while ((i < m) && (j < n))
     {
-      cout << a[i++];
-      j++;
+        if (a[i] < b[j])
+            cout << a[i++] << " ";
+        else if (a[i] > b[j])
+            cout << b[j++] << " ";
+        else
+        {
+            cout << a[i++];
+            j++;
+        }
     }
-  }
-  while (i < m)
-    cout << a[i++] << " ";
-  while (j < n)
-    cout << b[j++] << " ";
-  return 0;
+    while (i < m) cout << a[i++] << " ";
+    while (j < n) cout << b[j++] << " ";
+    return 0;
 }
diff --git a/others/buzz_number.cpp b/others/buzz_number.cpp
index ed9fc5f28..712b79401 100644
--- a/others/buzz_number.cpp
+++ b/others/buzz_number.cpp
@@ -6,10 +6,12 @@
 #include <iostream>
 
 /** main function */
-int main() {
+int main()
+{
     int n, t;
     std::cin >> t;
-    while (t--) {
+    while (t--)
+    {
         std::cin >> n;
         if ((n % 7 == 0) || (n % 10 == 7))
             std::cout << n << " is a buzz number" << std::endl;
diff --git a/others/decimal_to_binary.cpp b/others/decimal_to_binary.cpp
index 11ce064a5..32616944f 100644
--- a/others/decimal_to_binary.cpp
+++ b/others/decimal_to_binary.cpp
@@ -8,10 +8,12 @@
  * This method converts the bit representation and stores it as a decimal
  * number.
  */
-void method1(int number) {
+void method1(int number)
+{
     int remainder, binary = 0, var = 1;
 
-    do {
+    do
+    {
         remainder = number % 2;
         number = number / 2;
         binary = binary + (remainder * var);
@@ -24,11 +26,13 @@ void method1(int number) {
  * This method stores each bit value from LSB to MSB and then prints them back
  * from MSB to LSB
  */
-void method2(int number) {
+void method2(int number)
+{
     int num_bits = 0;
     char bit_string[50];
 
-    do {
+    do
+    {
         bool bit = number & 0x01;  // get last bit
         if (bit)
             bit_string[num_bits++] = '1';
@@ -43,7 +47,8 @@ void method2(int number) {
     std::cout << std::endl;
 }
 
-int main() {
+int main()
+{
     int number;
     std::cout << "Enter a number:";
     std::cin >> number;
diff --git a/others/decimal_to_hexadecimal.cpp b/others/decimal_to_hexadecimal.cpp
index a3e544f49..f0a521db6 100644
--- a/others/decimal_to_hexadecimal.cpp
+++ b/others/decimal_to_hexadecimal.cpp
@@ -8,7 +8,8 @@
 /**
  * Main program
  */
-int main(void) {
+int main(void)
+{
     int valueToConvert = 0;  // Holds user input
     int hexArray[8];         // Contains hex values backwards
     int i = 0;               // counter
@@ -19,7 +20,8 @@ int main(void) {
     std::cin >>
         valueToConvert;  // Stores value into valueToConvert via user input
 
-    while (valueToConvert > 15) {             // Dec to Hex Algorithm
+    while (valueToConvert > 15)
+    {                                         // Dec to Hex Algorithm
         hexArray[i++] = valueToConvert % 16;  // Gets remainder
         valueToConvert /= 16;
         // valueToConvert >>= 4;  // This will divide by 2^4=16 and is faster
diff --git a/others/decimal_to_roman_numeral.cpp b/others/decimal_to_roman_numeral.cpp
index 6bd1be395..fbcbaa232 100644
--- a/others/decimal_to_roman_numeral.cpp
+++ b/others/decimal_to_roman_numeral.cpp
@@ -12,7 +12,8 @@
 /** This functions fills a string with character c, n times and returns it
  * @note This can probably be replace by `memcpy` function.
  */
-std::string fill(char c, int n) {
+std::string fill(char c, int n)
+{
     std::string s = "";
     while (n--) s += c;
     return s;
@@ -21,51 +22,76 @@ std::string fill(char c, int n) {
 /** to convert to lowercase Roman Numeral
  * the function works recursively
  */
-std::string tolowerRoman(int n) {
-    if (n < 4) return fill('i', n);
-    if (n < 6) return fill('i', 5 - n) + "v";
-    if (n < 9) return std::string("v") + fill('i', n - 5);
-    if (n < 11) return fill('i', 10 - n) + "x";
-    if (n < 40) return fill('x', n / 10) + tolowerRoman(n % 10);
-    if (n < 60) return fill('x', 5 - n / 10) + 'l' + tolowerRoman(n % 10);
+std::string tolowerRoman(int n)
+{
+    if (n < 4)
+        return fill('i', n);
+    if (n < 6)
+        return fill('i', 5 - n) + "v";
+    if (n < 9)
+        return std::string("v") + fill('i', n - 5);
+    if (n < 11)
+        return fill('i', 10 - n) + "x";
+    if (n < 40)
+        return fill('x', n / 10) + tolowerRoman(n % 10);
+    if (n < 60)
+        return fill('x', 5 - n / 10) + 'l' + tolowerRoman(n % 10);
     if (n < 90)
         return std::string("l") + fill('x', n / 10 - 5) + tolowerRoman(n % 10);
-    if (n < 110) return fill('x', 10 - n / 10) + "c" + tolowerRoman(n % 10);
-    if (n < 400) return fill('c', n / 100) + tolowerRoman(n % 100);
-    if (n < 600) return fill('c', 5 - n / 100) + 'd' + tolowerRoman(n % 100);
+    if (n < 110)
+        return fill('x', 10 - n / 10) + "c" + tolowerRoman(n % 10);
+    if (n < 400)
+        return fill('c', n / 100) + tolowerRoman(n % 100);
+    if (n < 600)
+        return fill('c', 5 - n / 100) + 'd' + tolowerRoman(n % 100);
     if (n < 900)
         return std::string("d") + fill('c', n / 100 - 5) +
                tolowerRoman(n % 100);
-    if (n < 1100) return fill('c', 10 - n / 100) + "m" + tolowerRoman(n % 100);
-    if (n < 4000) return fill('m', n / 1000) + tolowerRoman(n % 1000);
+    if (n < 1100)
+        return fill('c', 10 - n / 100) + "m" + tolowerRoman(n % 100);
+    if (n < 4000)
+        return fill('m', n / 1000) + tolowerRoman(n % 1000);
     return "?";
 }
 
 /** to convert to uppercase Roman Numeral
  * the function works recursively
  */
-std::string toupperRoman(int n) {
-    if (n < 4) return fill('I', n);
-    if (n < 6) return fill('I', 5 - n) + "V";
-    if (n < 9) return std::string("V") + fill('I', n - 5);
-    if (n < 11) return fill('I', 10 - n) + "X";
-    if (n < 40) return fill('X', n / 10) + toupperRoman(n % 10);
-    if (n < 60) return fill('X', 5 - n / 10) + 'L' + toupperRoman(n % 10);
+std::string toupperRoman(int n)
+{
+    if (n < 4)
+        return fill('I', n);
+    if (n < 6)
+        return fill('I', 5 - n) + "V";
+    if (n < 9)
+        return std::string("V") + fill('I', n - 5);
+    if (n < 11)
+        return fill('I', 10 - n) + "X";
+    if (n < 40)
+        return fill('X', n / 10) + toupperRoman(n % 10);
+    if (n < 60)
+        return fill('X', 5 - n / 10) + 'L' + toupperRoman(n % 10);
     if (n < 90)
         return std::string("L") + fill('X', n / 10 - 5) + toupperRoman(n % 10);
-    if (n < 110) return fill('X', 10 - n / 10) + "C" + toupperRoman(n % 10);
-    if (n < 400) return fill('C', n / 100) + toupperRoman(n % 100);
-    if (n < 600) return fill('C', 5 - n / 100) + 'D' + toupperRoman(n % 100);
+    if (n < 110)
+        return fill('X', 10 - n / 10) + "C" + toupperRoman(n % 10);
+    if (n < 400)
+        return fill('C', n / 100) + toupperRoman(n % 100);
+    if (n < 600)
+        return fill('C', 5 - n / 100) + 'D' + toupperRoman(n % 100);
     if (n < 900)
         return std::string("D") + fill('C', n / 100 - 5) +
                toupperRoman(n % 100);
-    if (n < 1100) return fill('C', 10 - n / 100) + "M" + toupperRoman(n % 100);
-    if (n < 4000) return fill('M', n / 1000) + toupperRoman(n % 1000);
+    if (n < 1100)
+        return fill('C', 10 - n / 100) + "M" + toupperRoman(n % 100);
+    if (n < 4000)
+        return fill('M', n / 1000) + toupperRoman(n % 1000);
     return "?";
 }
 
 /** main function */
-int main() {
+int main()
+{
     int n;
     std::cout << "\t\tRoman numbers converter\n\n";
     std::cout << "Type in decimal number between 0 up to 4000 (exclusive): ";
diff --git a/others/fast_interger_input.cpp b/others/fast_interger_input.cpp
index 5e7bcb99d..a71e807dd 100644
--- a/others/fast_interger_input.cpp
+++ b/others/fast_interger_input.cpp
@@ -8,7 +8,8 @@
 /** Function to read the number from stdin. The function reads input until a non
  * numeric character is entered.
  */
-void fastinput(int *number) {
+void fastinput(int *number)
+{
     // variable to indicate sign of input integer
     bool negative = false;
     register int c;
@@ -16,7 +17,8 @@ void fastinput(int *number) {
 
     // extract current character from buffer
     c = std::getchar();
-    if (c == '-') {
+    if (c == '-')
+    {
         // number is negative
         negative = true;
 
@@ -31,11 +33,13 @@ void fastinput(int *number) {
 
     // if scanned input has a negative sign, negate the
     // value of the input number
-    if (negative) *(number) *= -1;
+    if (negative)
+        *(number) *= -1;
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int number;
     fastinput(&number);
     std::cout << number << std::endl;
diff --git a/others/happy_number.cpp b/others/happy_number.cpp
index b1debaa54..494891e3b 100644
--- a/others/happy_number.cpp
+++ b/others/happy_number.cpp
@@ -11,10 +11,13 @@
  * \returns true if happy else false
  */
 template <typename T>
-bool is_happy(T n) {
-    T s = 0;              // stores sum of digits
-    while (n > 9) {       // while number is > 9, there are more than 1 digit
-        while (n != 0) {  // get digit
+bool is_happy(T n)
+{
+    T s = 0;  // stores sum of digits
+    while (n > 9)
+    {  // while number is > 9, there are more than 1 digit
+        while (n != 0)
+        {  // get digit
             T d = n % 10;
             s += d;
             n /= 10;
@@ -26,7 +29,8 @@ bool is_happy(T n) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int n;
     std::cout << "Enter a number:";
     std::cin >> n;
diff --git a/others/matrix_exponentiation.cpp b/others/matrix_exponentiation.cpp
index d44d22593..78daca8ec 100644
--- a/others/matrix_exponentiation.cpp
+++ b/others/matrix_exponentiation.cpp
@@ -58,11 +58,15 @@ vector<ll> a, b, c;
  * \result matrix of dimension (m\f$\times\f$q)
  */
 vector<vector<ll>> multiply(const vector<vector<ll>> &A,
-                            const vector<vector<ll>> &B) {
+                            const vector<vector<ll>> &B)
+{
     vector<vector<ll>> C(k + 1, vector<ll>(k + 1));
-    for (ll i = 1; i <= k; i++) {
-        for (ll j = 1; j <= k; j++) {
-            for (ll z = 1; z <= k; z++) {
+    for (ll i = 1; i <= k; i++)
+    {
+        for (ll j = 1; j <= k; j++)
+        {
+            for (ll z = 1; z <= k; z++)
+            {
                 C[i][j] = (C[i][j] + (A[i][z] * B[z][j]) % MOD) % MOD;
             }
         }
@@ -76,12 +80,16 @@ vector<vector<ll>> multiply(const vector<vector<ll>> &A,
  * \param [in] p exponent
  * \return matrix of same dimension as A
  */
-vector<vector<ll>> power(const vector<vector<ll>> &A, ll p) {
+vector<vector<ll>> power(const vector<vector<ll>> &A, ll p)
+{
     if (p == 1)
         return A;
-    if (p % 2 == 1) {
+    if (p % 2 == 1)
+    {
         return multiply(A, power(A, p - 1));
-    } else {
+    }
+    else
+    {
         vector<vector<ll>> X = power(A, p / 2);
         return multiply(X, X);
     }
@@ -91,7 +99,8 @@ vector<vector<ll>> power(const vector<vector<ll>> &A, ll p) {
  * \param[in] n \f$n^\text{th}\f$ Fibonacci number
  * \return \f$n^\text{th}\f$ Fibonacci number
  */
-ll ans(ll n) {
+ll ans(ll n)
+{
     if (n == 0)
         return 0;
     if (n <= k)
@@ -102,9 +111,12 @@ ll ans(ll n) {
 
     // Transpose matrix
     vector<vector<ll>> T(k + 1, vector<ll>(k + 1));
-    for (ll i = 1; i <= k; i++) {
-        for (ll j = 1; j <= k; j++) {
-            if (i < k) {
+    for (ll i = 1; i <= k; i++)
+    {
+        for (ll j = 1; j <= k; j++)
+        {
+            if (i < k)
+            {
                 if (j == i + 1)
                     T[i][j] = 1;
                 else
@@ -119,26 +131,31 @@ ll ans(ll n) {
 
     // T*F1
     ll res = 0;
-    for (ll i = 1; i <= k; i++) {
+    for (ll i = 1; i <= k; i++)
+    {
         res = (res + (T[1][i] * F1[i]) % MOD) % MOD;
     }
     return res;
 }
 
 /** Main function */
-int main() {
+int main()
+{
     cin.tie(0);
     cout.tie(0);
     ll t;
     cin >> t;
     ll i, j, x;
-    while (t--) {
+    while (t--)
+    {
         cin >> k;
-        for (i = 0; i < k; i++) {
+        for (i = 0; i < k; i++)
+        {
             cin >> x;
             b.pb(x);
         }
-        for (i = 0; i < k; i++) {
+        for (i = 0; i < k; i++)
+        {
             cin >> x;
             c.pb(x);
         }
diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index 66401ff96..d6ed3fc70 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -16,7 +16,8 @@
 #endif
 
 /** Main function */
-int main() {
+int main()
+{
     int num;
     std::cout << "Enter number = ";
     std::cin >> num;
diff --git a/others/paranthesis_matching.cpp b/others/paranthesis_matching.cpp
index ef5da6e47..95a9e1100 100644
--- a/others/paranthesis_matching.cpp
+++ b/others/paranthesis_matching.cpp
@@ -33,41 +33,53 @@ char pop() { return stack[top--]; }
 /** return opening paranthesis corresponding to the close paranthesis
  * @param[in] ch closed paranthesis character
  */
-char opening(char ch) {
-    switch (ch) {
-        case '}':
-            return '{';
-        case ']':
-            return '[';
-        case ')':
-            return '(';
-        case '>':
-            return '<';
+char opening(char ch)
+{
+    switch (ch)
+    {
+    case '}':
+        return '{';
+    case ']':
+        return '[';
+    case ')':
+        return '(';
+    case '>':
+        return '<';
     }
     return '\0';
 }
 
-int main() {
+int main()
+{
     std::string exp;
     int valid = 1, i = 0;
     std::cout << "Enter The Expression : ";
     std::cin >> exp;
 
-    while (valid == 1 && i < exp.length()) {
-        if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<') {
+    while (valid == 1 && i < exp.length())
+    {
+        if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<')
+        {
             push(exp[i]);
-        } else if (top >= 0 && stack[top] == opening(exp[i])) {
+        }
+        else if (top >= 0 && stack[top] == opening(exp[i]))
+        {
             pop();
-        } else {
+        }
+        else
+        {
             valid = 0;
         }
         i++;
     }
 
     // makes sure the stack is empty after processsing (above)
-    if (valid == 1 && top == -1) {
+    if (valid == 1 && top == -1)
+    {
         std::cout << "\nCorrect Expression";
-    } else {
+    }
+    else
+    {
         std::cout << "\nWrong Expression";
     }
 
diff --git a/others/pascal_triangle.cpp b/others/pascal_triangle.cpp
index 4ea58f3f1..814b9a142 100644
--- a/others/pascal_triangle.cpp
+++ b/others/pascal_triangle.cpp
@@ -15,9 +15,12 @@
  * \param [in] arr  2D-array containing Pascal numbers
  * \param [in] n    depth of Pascal triangle to print
  */
-void show_pascal(int **arr, int n) {
-    for (int i = 0; i < n; ++i) {
-        for (int j = 0; j < n + i; ++j) {
+void show_pascal(int **arr, int n)
+{
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 0; j < n + i; ++j)
+        {
             if (arr[i][j] == 0)
                 std::cout << std::setw(4) << " ";
             else
@@ -33,9 +36,12 @@ void show_pascal(int **arr, int n) {
  * \param [in] n    depth of Pascal triangle to print
  * \result arr pointer returned
  */
-int **pascal_triangle(int **arr, int n) {
-    for (int i = 0; i < n; ++i) {
-        for (int j = n - i - 1; j < n + i; ++j) {
+int **pascal_triangle(int **arr, int n)
+{
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = n - i - 1; j < n + i; ++j)
+        {
             if (j == n - i - 1 || j == n + i - 1)
                 arr[i][j] = 1;  // The edge of the Pascal triangle goes in 1
             else
@@ -49,7 +55,8 @@ int **pascal_triangle(int **arr, int n) {
 /**
  * main function
  */
-int main() {
+int main()
+{
     int n = 0;
 
     std::cout << "Set Pascal's Triangle Height" << std::endl;
@@ -57,7 +64,8 @@ int main() {
 
     // memory allocation (Assign two-dimensional array to store Pascal triangle)
     int **arr = new int *[n];
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i)
+    {
         arr[i] = new int[2 * n - 1];
         memset(arr[i], 0, sizeof(int) * (2 * n - 1));
     }
@@ -66,7 +74,8 @@ int main() {
     show_pascal(arr, n);
 
     // deallocation
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i)
+    {
         delete[] arr[i];
     }
     delete[] arr;
diff --git a/others/primality_test.cpp b/others/primality_test.cpp
index faec6589c..16700ec4a 100644
--- a/others/primality_test.cpp
+++ b/others/primality_test.cpp
@@ -15,12 +15,14 @@
  * \param[in] number number to check
  * \returns true if prime else false
  */
-bool IsPrime(int number) {
+bool IsPrime(int number)
+{
     if (((!(number & 1)) && number != 2) || (number < 2) ||
         (number % 3 == 0 && number != 3))
         return false;
 
-    for (int k = 1; 36 * k * k - 12 * k < number; ++k) {
+    for (int k = 1; 36 * k * k - 12 * k < number; ++k)
+    {
         if ((number % (6 * k + 1) == 0) || (number % (6 * k - 1) == 0))
             return false;
     }
@@ -28,7 +30,8 @@ bool IsPrime(int number) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     // Main Function
     std::cout << "Enter the value of n to check if Prime\n";
     int n;
diff --git a/others/smallest_circle.cpp b/others/smallest_circle.cpp
index 9ee4353eb..5842a33c8 100644
--- a/others/smallest_circle.cpp
+++ b/others/smallest_circle.cpp
@@ -12,7 +12,8 @@
 #include <vector>
 
 /** Define a point */
-struct Point {
+struct Point
+{
     double x, /**< abscissa */
         y;    /**< ordinate */
 
@@ -20,7 +21,8 @@ struct Point {
      * \param [in] a absicca (default = 0.0)
      * \param [in] b ordinate (default = 0.0)
      */
-    explicit Point(double a = 0.f, double b = 0.f) {
+    explicit Point(double a = 0.f, double b = 0.f)
+    {
         x = a;
         y = b;
     }
@@ -34,7 +36,8 @@ struct Point {
  * \param [in] B point B
  * \return ditance
  */
-double LenghtLine(const Point &A, const Point &B) {
+double LenghtLine(const Point &A, const Point &B)
+{
     double dx = B.x - A.x;
     double dy = B.y - A.y;
     return std::sqrt((dx * dx) + (dy * dy));
@@ -51,7 +54,8 @@ double LenghtLine(const Point &A, const Point &B) {
  * \param [in] C vertex C
  * \returns area of triangle
  */
-double TriangleArea(const Point &A, const Point &B, const Point &C) {
+double TriangleArea(const Point &A, const Point &B, const Point &C)
+{
     double a = LenghtLine(A, B);
     double b = LenghtLine(B, C);
     double c = LenghtLine(C, A);
@@ -69,8 +73,10 @@ double TriangleArea(const Point &A, const Point &B, const Point &C) {
  * \returns True if P lies on or within the circle
  * \returns False if P lies outside the circle
  */
-bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R) {
-    for (size_t i = 0; i < P.size(); i++) {
+bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R)
+{
+    for (size_t i = 0; i < P.size(); i++)
+    {
         if (LenghtLine(P[i], Center) > R)
             return false;
     }
@@ -84,7 +90,8 @@ bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R) {
  * \param [in] P vector of points
  * \returns radius of the circle
  */
-double circle(const std::vector<Point> &P) {
+double circle(const std::vector<Point> &P)
+{
     double minR = INFINITY;
     double R;
     Point C;
@@ -96,7 +103,8 @@ double circle(const std::vector<Point> &P) {
         // for every subsequent point in the list
         for (size_t j = i + 1; j < P.size(); j++)
             // for every subsequent point in the list
-            for (size_t k = j + 1; k < P.size(); k++) {
+            for (size_t k = j + 1; k < P.size(); k++)
+            {
                 // here, we now have picked three points from the given set of
                 // points that we can use
                 // viz., P[i], P[j] and P[k]
@@ -121,10 +129,12 @@ double circle(const std::vector<Point> &P) {
                 R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k]) *
                      LenghtLine(P[k], P[i])) /
                     (4 * TriangleArea(P[i], P[j], P[k]));
-                if (!PointInCircle(P, C, R)) {
+                if (!PointInCircle(P, C, R))
+                {
                     continue;
                 }
-                if (R <= minR) {
+                if (R <= minR)
+                {
                     minR = R;
                     minC = C;
                 }
@@ -133,15 +143,18 @@ double circle(const std::vector<Point> &P) {
     // for each point in the list
     for (size_t i = 0; i < P.size() - 1; i++)
         // for every subsequent point in the list
-        for (size_t j = i + 1; j < P.size(); j++) {
+        for (size_t j = i + 1; j < P.size(); j++)
+        {
             // check for diameterically opposite points
             C.x = (P[i].x + P[j].x) / 2;
             C.y = (P[i].y + P[j].y) / 2;
             R = LenghtLine(C, P[i]);
-            if (!PointInCircle(P, C, R)) {
+            if (!PointInCircle(P, C, R))
+            {
                 continue;
             }
-            if (R <= minR) {
+            if (R <= minR)
+            {
                 minR = R;
                 minC = C;
             }
@@ -155,7 +168,8 @@ double circle(const std::vector<Point> &P) {
  * \n radius 3.318493136080724
  * \n centre at (3.0454545454545454, 1.3181818181818181)
  */
-void test() {
+void test()
+{
     std::vector<Point> Pv;
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(5, 4));
@@ -170,7 +184,8 @@ void test() {
  * \n radius 1.4142135623730951
  * \n centre at (1.0, 1.0)
  */
-void test2() {
+void test2()
+{
     std::vector<Point> Pv;
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(0, 2));
@@ -185,7 +200,8 @@ void test2() {
  * \n centre at (2.142857142857143, 1.7857142857142856)
  * @todo This test fails
  */
-void test3() {
+void test3()
+{
     std::vector<Point> Pv;
     Pv.push_back(Point(0.5, 1));
     Pv.push_back(Point(3.5, 3));
@@ -195,7 +211,8 @@ void test3() {
 }
 
 /** Main program */
-int main() {
+int main()
+{
     test();
     std::cout << std::endl;
     test2();
diff --git a/others/sparse_matrix.cpp b/others/sparse_matrix.cpp
index a358f0da4..5662e065d 100644
--- a/others/sparse_matrix.cpp
+++ b/others/sparse_matrix.cpp
@@ -6,7 +6,8 @@
 #include <iostream>
 
 /** main function */
-int main() {
+int main()
+{
     int m, n;
     int counterZeros = 0;
 
@@ -21,16 +22,20 @@ int main() {
     std::cout << "\n";
 
     // reads the matrix from stdin
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
             std::cout << "element? ";
             std::cin >> a[i][j];
         }
     }
 
     // counts the zero's
-    for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
+    for (int i = 0; i < m; i++)
+    {
+        for (int j = 0; j < n; j++)
+        {
             if (a[i][j] == 0)
                 counterZeros++;  // Counting number of zeroes
         }
diff --git a/others/spiral_print.cpp b/others/spiral_print.cpp
index 02dc3183a..da92e6937 100644
--- a/others/spiral_print.cpp
+++ b/others/spiral_print.cpp
@@ -9,10 +9,13 @@
  * \param [in] r number of rows
  * \param [in] c number of columns
  */
-void genArray(int **a, int r, int c) {
+void genArray(int **a, int r, int c)
+{
     int value = 1;
-    for (int i = 0; i < r; i++) {
-        for (int j = 0; j < c; j++) {
+    for (int i = 0; i < r; i++)
+    {
+        for (int j = 0; j < c; j++)
+        {
             a[i][j] = value;
             std::cout << a[i][j] << " ";
             value++;
@@ -26,39 +29,47 @@ void genArray(int **a, int r, int c) {
  * \param [in] r number of rows
  * \param [in] c number of columns
  */
-void spiralPrint(int **a, int r, int c) {
+void spiralPrint(int **a, int r, int c)
+{
     int startRow = 0, endRow = r - 1;
     int startCol = 0, endCol = c - 1;
     int cnt = 0;
 
-    while (startRow <= endRow && startCol <= endCol) {
+    while (startRow <= endRow && startCol <= endCol)
+    {
         /// Print start row
-        for (int i = startCol; i <= endCol; i++, cnt++) {
+        for (int i = startCol; i <= endCol; i++, cnt++)
+        {
             std::cout << a[startRow][i] << " ";
         }
         startRow++;
 
         /// Print the end col
-        for (int i = startRow; i <= endRow; i++, cnt++) {
+        for (int i = startRow; i <= endRow; i++, cnt++)
+        {
             std::cout << a[i][endCol] << " ";
         }
         endCol--;
 
         /// Print the end row
-        if (cnt == r * c) {
+        if (cnt == r * c)
+        {
             break;
         }
 
-        for (int i = endCol; i >= startCol; i--, cnt++) {
+        for (int i = endCol; i >= startCol; i--, cnt++)
+        {
             std::cout << a[endRow][i] << " ";
         }
         endRow--;
 
         /// Print the start Col
-        if (cnt == r * c) {
+        if (cnt == r * c)
+        {
             break;
         }
-        for (int i = endRow; i >= startRow; i--, cnt++) {
+        for (int i = endRow; i >= startRow; i--, cnt++)
+        {
             std::cout << a[i][startCol] << " ";
         }
         startCol++;
@@ -66,7 +77,8 @@ void spiralPrint(int **a, int r, int c) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     int r, c;
     std::cin >> r >> c;
     int **a = new int *[r];
diff --git a/others/stairs_pattern.cpp b/others/stairs_pattern.cpp
index a3b8b0a44..bfd90dd10 100644
--- a/others/stairs_pattern.cpp
+++ b/others/stairs_pattern.cpp
@@ -14,18 +14,23 @@ where number of pairs line is given by user
 #include <iostream>
 
 /** main function */
-int main() {
+int main()
+{
     int l, st = 2, x, r, z, n, sp;
     std::cout << "enter Index ";
     std::cin >> x;
     z = x;
-    for (r = 1; r <= x; r++) {
+    for (r = 1; r <= x; r++)
+    {
         z = z - 1;
-        for (n = 1; n <= 2; n++) {
-            for (sp = 1; sp <= z; sp++) {
+        for (n = 1; n <= 2; n++)
+        {
+            for (sp = 1; sp <= z; sp++)
+            {
                 std::cout << " ";
             }
-            for (l = 1; l <= st; l++) {
+            for (l = 1; l <= st; l++)
+            {
                 std::cout << "*";
             }
             std::cout << std::endl;
diff --git a/others/tower_of_hanoi.cpp b/others/tower_of_hanoi.cpp
index 323b2e424..3a832248f 100644
--- a/others/tower_of_hanoi.cpp
+++ b/others/tower_of_hanoi.cpp
@@ -8,7 +8,8 @@
 /**
  * Define the state of tower
  */
-struct tower {
+struct tower
+{
     //! Values in the tower
     int values[10];
     //! top tower ID
@@ -17,17 +18,21 @@ struct tower {
 
 /** Display the towers */
 void show(const struct tower *const F, const struct tower *const T,
-          const struct tower *const U) {
+          const struct tower *const U)
+{
     std::cout << "\n\n\tF : ";
-    for (int i = 0; i < F->top; i++) {
+    for (int i = 0; i < F->top; i++)
+    {
         std::cout << F->values[i] << "\t";
     }
     std::cout << "\n\tU : ";
-    for (int i = 0; i < U->top; i++) {
+    for (int i = 0; i < U->top; i++)
+    {
         std::cout << U->values[i] << "\t";
     }
     std::cout << "\n\tT : ";
-    for (int i = 0; i < T->top; i++) {
+    for (int i = 0; i < T->top; i++)
+    {
         std::cout << T->values[i] << "\t";
     }
 }
@@ -36,7 +41,8 @@ void show(const struct tower *const F, const struct tower *const T,
  * \param [in,out] From tower to move disk *from*
  * \param [in,out] To  tower to move disk *to*
  */
-void mov(tower *From, tower *To) {
+void mov(tower *From, tower *To)
+{
     --From->top;
     To->values[To->top] = From->values[From->top];
     ++To->top;
@@ -49,11 +55,15 @@ void mov(tower *From, tower *To) {
  * \param [in,out] Using temporary tower for the puzzle
  * \param [in,out] To  tower to move disk to
  */
-void TH(int n, tower *From, tower *Using, tower *To) {
-    if (n == 1) {
+void TH(int n, tower *From, tower *Using, tower *To)
+{
+    if (n == 1)
+    {
         mov(From, To);
         show(From, To, Using);
-    } else {
+    }
+    else
+    {
         TH(n - 1, From, To, Using);
         mov(From, To);
         show(From, To, Using);
@@ -62,7 +72,8 @@ void TH(int n, tower *From, tower *Using, tower *To) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     struct tower F, U, T;
 
     F.top = 0;
@@ -74,7 +85,8 @@ int main() {
     std::cout << "\nEnter number of discs : ";
     std::cin >> no;
 
-    for (int i = no; i > 0; i--) {
+    for (int i = no; i > 0; i--)
+    {
         F.values[F.top++] = i;
     }
 
diff --git a/others/vector_important_functions.cpp b/others/vector_important_functions.cpp
index d23ff9c97..765f6a8e5 100644
--- a/others/vector_important_functions.cpp
+++ b/others/vector_important_functions.cpp
@@ -8,7 +8,8 @@
 #include <vector>
 
 /** Main function */
-int main() {
+int main()
+{
     // Initializing vector with array values
     int arr[] = {10, 20, 5, 23, 42, 15};
     int n = sizeof(arr) / sizeof(arr[0]);
diff --git a/probability/addition_rule.cpp b/probability/addition_rule.cpp
index 780951489..0666b29e6 100644
--- a/probability/addition_rule.cpp
+++ b/probability/addition_rule.cpp
@@ -11,7 +11,8 @@
  * \parama [in] B probability of event B
  * \returns probability of A and B
  */
-double addition_rule_independent(double A, double B) {
+double addition_rule_independent(double A, double B)
+{
     return (A + B) - (A * B);
 }
 
@@ -22,12 +23,14 @@ double addition_rule_independent(double A, double B) {
  * \parama [in] B_given_A probability of event B condition A
  * \returns probability of A and B
  */
-double addition_rule_dependent(double A, double B, double B_given_A) {
+double addition_rule_dependent(double A, double B, double B_given_A)
+{
     return (A + B) - (A * B_given_A);
 }
 
 /** Main function */
-int main() {
+int main()
+{
     double A = 0.5;
     double B = 0.25;
     double B_given_A = 0.05;
diff --git a/probability/bayes_theorem.cpp b/probability/bayes_theorem.cpp
index aaa557a94..632611fe5 100644
--- a/probability/bayes_theorem.cpp
+++ b/probability/bayes_theorem.cpp
@@ -11,19 +11,22 @@
 
 /** returns P(A|B)
  */
-double bayes_AgivenB(double BgivenA, double A, double B) {
+double bayes_AgivenB(double BgivenA, double A, double B)
+{
     return (BgivenA * A) / B;
 }
 
 /** returns P(B|A)
  */
-double bayes_BgivenA(double AgivenB, double A, double B) {
+double bayes_BgivenA(double AgivenB, double A, double B)
+{
     return (AgivenB * B) / A;
 }
 
 /** Main function
  */
-int main() {
+int main()
+{
     double A = 0.01;
     double B = 0.1;
     double BgivenA = 0.9;
diff --git a/probability/binomial_dist.cpp b/probability/binomial_dist.cpp
index 1f30c5048..4d2e90842 100644
--- a/probability/binomial_dist.cpp
+++ b/probability/binomial_dist.cpp
@@ -33,7 +33,8 @@ double binomial_variance(double n, double p) { return n * p * (1 - p); }
  * \param [in] p
  * \returns \f$\sigma = \sqrt{\sigma^2} = \sqrt{n\cdot p\cdot (1-p)}\f$
  */
-double binomial_standard_deviation(double n, double p) {
+double binomial_standard_deviation(double n, double p)
+{
     return std::sqrt(binomial_variance(n, p));
 }
 
@@ -44,15 +45,18 @@ double binomial_standard_deviation(double n, double p) {
  * \frac{n!}{r!(n-r)!} = \frac{n\times(n-1)\times(n-2)\times\cdots(n-r)}{r!}
  * \f$
  */
-double nCr(double n, double r) {
+double nCr(double n, double r)
+{
     double numerator = n;
     double denominator = r;
 
-    for (int i = n - 1; i >= ((n - r) + 1); i--) {
+    for (int i = n - 1; i >= ((n - r) + 1); i--)
+    {
         numerator *= i;
     }
 
-    for (int i = 1; i < r; i++) {
+    for (int i = 1; i < r; i++)
+    {
         denominator *= i;
     }
 
@@ -62,7 +66,8 @@ double nCr(double n, double r) {
 /** calculates the probability of exactly x successes
  * \returns \f$\displaystyle P(n,p,x) = {n\choose x} p^x (1-p)^{n-x}\f$
  */
-double binomial_x_successes(double n, double p, double x) {
+double binomial_x_successes(double n, double p, double x)
+{
     return nCr(n, x) * std::pow(p, x) * std::pow(1 - p, n - x);
 }
 
@@ -72,16 +77,19 @@ double binomial_x_successes(double n, double p, double x) {
  * =\sum_{i=x_0}^{x_1} {n\choose i} p^i (1-p)^{n-i}\f$
  */
 double binomial_range_successes(double n, double p, double lower_bound,
-                                double upper_bound) {
+                                double upper_bound)
+{
     double probability = 0;
-    for (int i = lower_bound; i <= upper_bound; i++) {
+    for (int i = lower_bound; i <= upper_bound; i++)
+    {
         probability += nCr(n, i) * std::pow(p, i) * std::pow(1 - p, n - i);
     }
     return probability;
 }
 
 /** main function */
-int main() {
+int main()
+{
     std::cout << "expected value : " << binomial_expected(100, 0.5)
               << std::endl;
 
diff --git a/probability/poisson_dist.cpp b/probability/poisson_dist.cpp
index 6a2a377c3..428ee903f 100644
--- a/probability/poisson_dist.cpp
+++ b/probability/poisson_dist.cpp
@@ -14,7 +14,8 @@
  * calculate the events per unit time\n
  * e.g 5 dollars every 2 mins = 5 / 2 = 2.5
  */
-double poisson_rate(double events, double timeframe) {
+double poisson_rate(double events, double timeframe)
+{
     return events / timeframe;
 }
 
@@ -27,13 +28,16 @@ double poisson_expected(double rate, double time) { return rate * time; }
 /**
  * Compute factorial of a given number
  */
-double fact(double x) {
+double fact(double x)
+{
     double x_fact = x;
-    for (int i = x - 1; i > 0; i--) {
+    for (int i = x - 1; i > 0; i--)
+    {
         x_fact *= i;
     }
 
-    if (x_fact <= 0) {
+    if (x_fact <= 0)
+    {
         x_fact = 1;
     }
     return x_fact;
@@ -43,7 +47,8 @@ double fact(double x) {
  * Find the probability of x successes in a Poisson dist.
  * \f[p(\mu,x) = \frac{\mu^x e^{-\mu}}{x!}\f]
  */
-double poisson_x_successes(double expected, double x) {
+double poisson_x_successes(double expected, double x)
+{
     return (std::pow(expected, x) * std::exp(-expected)) / fact(x);
 }
 
@@ -51,9 +56,11 @@ double poisson_x_successes(double expected, double x) {
  * probability of a success in range for Poisson dist (inclusive, inclusive)
  * \f[P = \sum_i p(\mu,i)\f]
  */
-double poisson_range_successes(double expected, double lower, double upper) {
+double poisson_range_successes(double expected, double lower, double upper)
+{
     double probability = 0;
-    for (int i = lower; i <= upper; i++) {
+    for (int i = lower; i <= upper; i++)
+    {
         probability += poisson_x_successes(expected, i);
     }
     return probability;
@@ -62,7 +69,8 @@ double poisson_range_successes(double expected, double lower, double upper) {
 /**
  * main function
  */
-int main() {
+int main()
+{
     double rate, expected;
     rate = poisson_rate(3, 1);
     std::cout << "Poisson rate : " << rate << std::endl;
diff --git a/range_queries/bit.cpp b/range_queries/bit.cpp
index e5e36ed24..19141b7f5 100644
--- a/range_queries/bit.cpp
+++ b/range_queries/bit.cpp
@@ -7,22 +7,18 @@ class Bit
 {
     int n;
     vector<int> bit;
-    inline int offset(int x)
+    inline int offset(int x) { return (x & (-x)); }
+
+ public:
+    Bit(vector<int>& arr)
     {
-        return (x & (-x));
-    }
-
-    public:
-
-        Bit(vector<int>& arr)
-	{
-            n = arr.size();
-            bit.assign(n + 1, 0);
-            for (int i = 0; i < n; ++i)
-	    {
-                update(i, arr[i]);
-            }
+        n = arr.size();
+        bit.assign(n + 1, 0);
+        for (int i = 0; i < n; ++i)
+        {
+            update(i, arr[i]);
         }
+    }
     Bit(int x)
     {
         n = x;
@@ -34,7 +30,7 @@ class Bit
         // Add val at id
         id++;
         while (id <= n)
-	{
+        {
             bit[id] += val;
             id += offset(id);
         }
@@ -46,23 +42,20 @@ class Bit
         id++;
         int res = 0;
         while (id > 0)
-	{
+        {
             res += bit[id];
             id -= offset(id);
         }
         return res;
     }
 
-    int sum_range(int l, int r)
-    {
-        return sum(r) - sum(l - 1);
-    }
+    int sum_range(int l, int r) { return sum(r) - sum(l - 1); }
 };
 
 int main()
 {
     int n = 5;
-    vector<int> arr = { 1, 2, 3, 4, 5 };
+    vector<int> arr = {1, 2, 3, 4, 5};
     Bit x(arr);
 
     assert(x.sum_range(0, 0) == 1);
@@ -72,5 +65,5 @@ int main()
     assert(x.sum_range(0, 0) == 6);
     assert(x.sum_range(0, 1) == 8);
     assert(x.sum_range(0, 2) == 11);
-	return 0;
+    return 0;
 }
diff --git a/range_queries/fenwicktree.cpp b/range_queries/fenwicktree.cpp
index a4d1a02de..d78cb0d48 100644
--- a/range_queries/fenwicktree.cpp
+++ b/range_queries/fenwicktree.cpp
@@ -1,4 +1,4 @@
-#include<iostream>
+#include <iostream>
 using namespace std;
 
 /**
@@ -6,47 +6,55 @@ using namespace std;
  * twos complement works good on this
  * also using ` x - (x & (x - 1)) `
  */
-#define lowbit(x) (x & (-x) )
+#define lowbit(x) (x & (-x))
 
 const int maxn = 1e5 + 7;
 int tree[maxn] = {0},
-                 range;             // segement of [1...range], notice it must be less than `maxn`
+    range;  // segement of [1...range], notice it must be less than `maxn`
 
-void update(int x, int c) {
-    while(x <= range) {
+void update(int x, int c)
+{
+    while (x <= range)
+    {
         tree[x] += c;
         x += lowbit(x);
     }
 }
-int query(int x) {
+int query(int x)
+{
     int ans = 0;
-    while(x) {
+    while (x)
+    {
         ans += tree[x];
         x -= lowbit(x);
     }
     return ans;
 }
-int query_segement(int l, int r) {
-    return query(r) - query(l - 1);
-}
+int query_segement(int l, int r) { return query(r) - query(l - 1); }
 
-int main() {
+int main()
+{
     cin >> range;
-    for(int i = 1; i <= range; i++) {
+    for (int i = 1; i <= range; i++)
+    {
         int num;
         cin >> num;
         update(i, num);
     }
     int q;
     cin >> q;
-    while(q--) {
+    while (q--)
+    {
         int op;
         cin >> op;
-        if(op == 0) {
+        if (op == 0)
+        {
             int l, r;
             cin >> l >> r;
             cout << query_segement(l, r) << endl;
-        } else {
+        }
+        else
+        {
             int x, c;
             cin >> x >> c;
             update(x, c);
diff --git a/range_queries/mo.cpp b/range_queries/mo.cpp
index 7172bd632..4cdcdf30d 100644
--- a/range_queries/mo.cpp
+++ b/range_queries/mo.cpp
@@ -5,73 +5,71 @@ int a[N], bucket[N], cnt[N];
 int bucket_size;
 struct query
 {
-	int l, r, i;
+    int l, r, i;
 } q[N];
 int ans = 0;
 
 void add(int index)
 {
-	cnt[a[index]]++;
-	if (cnt[a[index]] == 1)
-		ans++;
+    cnt[a[index]]++;
+    if (cnt[a[index]] == 1)
+        ans++;
 }
 void remove(int index)
 {
-	cnt[a[index]]--;
-	if (cnt[a[index]] == 0)
-		ans--;
+    cnt[a[index]]--;
+    if (cnt[a[index]] == 0)
+        ans--;
 }
 
 bool mycmp(query x, query y)
 {
-	if (x.l / bucket_size != y.l / bucket_size)
-		return x.l / bucket_size < y.l / bucket_size;
-	return x.r < y.r;
+    if (x.l / bucket_size != y.l / bucket_size)
+        return x.l / bucket_size < y.l / bucket_size;
+    return x.r < y.r;
 }
 
 int main()
 {
-	int n, t, i, j, k = 0;
-	scanf("%d", &n);
-	for (i = 0; i < n; i++)
-		scanf("%d", &a[i]);
-	bucket_size = ceil(sqrt(n));
-	scanf("%d", &t);
-	for (i = 0; i < t; i++)
-	{
-		scanf("%d %d", &q[i].l, &q[i].r);
-		q[i].l--;
-		q[i].r--;
-		q[i].i = i;
-	}
-	sort(q, q + t, mycmp);
-	int left = 0, right = 0;
-	for (i = 0; i < t; i++)
-	{
-		int L = q[i].l, R = q[i].r;
-		while (left < L)
-		{
-			remove(left);
-			left++;
-		}
-		while (left > L)
-		{
-			add(left - 1);
-			left--;
-		}
-		while (right <= R)
-		{
-			add(right);
-			right++;
-		}
-		while (right > R + 1)
-		{
-			remove(right - 1);
-			right--;
-		}
-		bucket[q[i].i] = ans;
-	}
-	for (i = 0; i < t; i++)
-		printf("%d\n", bucket[i]);
-	return 0;
+    int n, t, i, j, k = 0;
+    scanf("%d", &n);
+    for (i = 0; i < n; i++) scanf("%d", &a[i]);
+    bucket_size = ceil(sqrt(n));
+    scanf("%d", &t);
+    for (i = 0; i < t; i++)
+    {
+        scanf("%d %d", &q[i].l, &q[i].r);
+        q[i].l--;
+        q[i].r--;
+        q[i].i = i;
+    }
+    sort(q, q + t, mycmp);
+    int left = 0, right = 0;
+    for (i = 0; i < t; i++)
+    {
+        int L = q[i].l, R = q[i].r;
+        while (left < L)
+        {
+            remove(left);
+            left++;
+        }
+        while (left > L)
+        {
+            add(left - 1);
+            left--;
+        }
+        while (right <= R)
+        {
+            add(right);
+            right++;
+        }
+        while (right > R + 1)
+        {
+            remove(right - 1);
+            right--;
+        }
+        bucket[q[i].i] = ans;
+    }
+    for (i = 0; i < t; i++) printf("%d\n", bucket[i]);
+    return 0;
 }
diff --git a/range_queries/segtree.cpp b/range_queries/segtree.cpp
index ee81453e1..fb2bbab13 100644
--- a/range_queries/segtree.cpp
+++ b/range_queries/segtree.cpp
@@ -1,92 +1,94 @@
 //#include <bits/stdc++.h>
-#incldue <iostream>
+#incldue < iostream >
 #define MAX 4000000
 using namespace std;
 typedef long long ll;
 void ConsTree(ll arr[], ll segtree[], ll low, ll high, ll pos)
 {
-	if (low == high)
-	{
-		segtree[pos] = arr[low];
-		return;
-	}
-	ll mid = (low + high) / 2;
-	ConsTree(arr, segtree, low, mid, 2 * pos + 1);
-	ConsTree(arr, segtree, mid + 1, high, 2 * pos + 2);
-	segtree[pos] = segtree[2 * pos + 1] + segtree[2 * pos + 2];
+    if (low == high)
+    {
+        segtree[pos] = arr[low];
+        return;
+    }
+    ll mid = (low + high) / 2;
+    ConsTree(arr, segtree, low, mid, 2 * pos + 1);
+    ConsTree(arr, segtree, mid + 1, high, 2 * pos + 2);
+    segtree[pos] = segtree[2 * pos + 1] + segtree[2 * pos + 2];
 }
 ll query(ll segtree[], ll lazy[], ll qlow, ll qhigh, ll low, ll high, ll pos)
 {
-	if (low > high)
-		return 0;
-	if (qlow > high || qhigh < low)
-		return 0;
-	if (lazy[pos] != 0)
-	{
-		segtree[pos] += lazy[pos] * (high - low + 1);
-		if (low != high)
-		{
-			lazy[2 * pos + 1] += lazy[pos];
-			lazy[2 * pos + 2] += lazy[pos];
-		}
-		lazy[pos] = 0;
-	}
-	if (qlow <= low && qhigh >= high)
-		return segtree[pos];
-	ll mid = (low + high) / 2;
-	return query(segtree, lazy, qlow, qhigh, low, mid, 2 * pos + 1) + query(segtree, lazy, qlow, qhigh, mid + 1, high, 2 * pos + 2);
+    if (low > high)
+        return 0;
+    if (qlow > high || qhigh < low)
+        return 0;
+    if (lazy[pos] != 0)
+    {
+        segtree[pos] += lazy[pos] * (high - low + 1);
+        if (low != high)
+        {
+            lazy[2 * pos + 1] += lazy[pos];
+            lazy[2 * pos + 2] += lazy[pos];
+        }
+        lazy[pos] = 0;
+    }
+    if (qlow <= low && qhigh >= high)
+        return segtree[pos];
+    ll mid = (low + high) / 2;
+    return query(segtree, lazy, qlow, qhigh, low, mid, 2 * pos + 1) +
+           query(segtree, lazy, qlow, qhigh, mid + 1, high, 2 * pos + 2);
 }
-void update(ll segtree[], ll lazy[], ll start, ll end, ll delta, ll low, ll high, ll pos)
+void update(ll segtree[], ll lazy[], ll start, ll end, ll delta, ll low,
+            ll high, ll pos)
 {
-	if (low > high)
-		return;
-	if (lazy[pos] != 0)
-	{
-		segtree[pos] += lazy[pos] * (high - low + 1);
-		if (low != high)
-		{
-			lazy[2 * pos + 1] += lazy[pos];
-			lazy[2 * pos + 2] += lazy[pos];
-		}
-		lazy[pos] = 0;
-	}
-	if (start > high || end < low)
-		return;
-	if (start <= low && end >= high)
-	{
-		segtree[pos] += delta * (high - low + 1);
-		if (low != high)
-		{
-			lazy[2 * pos + 1] += delta;
-			lazy[2 * pos + 2] += delta;
-		}
-		return;
-	}
-	ll mid = (low + high) / 2;
-	update(segtree, lazy, start, end, delta, low, mid, 2 * pos + 1);
-	update(segtree, lazy, start, end, delta, mid + 1, high, 2 * pos + 2);
-	segtree[pos] = segtree[2 * pos + 1] + segtree[2 * pos + 2];
+    if (low > high)
+        return;
+    if (lazy[pos] != 0)
+    {
+        segtree[pos] += lazy[pos] * (high - low + 1);
+        if (low != high)
+        {
+            lazy[2 * pos + 1] += lazy[pos];
+            lazy[2 * pos + 2] += lazy[pos];
+        }
+        lazy[pos] = 0;
+    }
+    if (start > high || end < low)
+        return;
+    if (start <= low && end >= high)
+    {
+        segtree[pos] += delta * (high - low + 1);
+        if (low != high)
+        {
+            lazy[2 * pos + 1] += delta;
+            lazy[2 * pos + 2] += delta;
+        }
+        return;
+    }
+    ll mid = (low + high) / 2;
+    update(segtree, lazy, start, end, delta, low, mid, 2 * pos + 1);
+    update(segtree, lazy, start, end, delta, mid + 1, high, 2 * pos + 2);
+    segtree[pos] = segtree[2 * pos + 1] + segtree[2 * pos + 2];
 }
 int main()
 {
-	ll n, c;
-	scanf("%lld %lld", &n, &c);
-	ll arr[n] = {0}, p, q, v, choice;
-	ll segtree[MAX], lazy[MAX] = {0};
-	ConsTree(arr, segtree, 0, n - 1, 0);
-	while (c--)
-	{
-		scanf("%lld", &choice);
-		if (choice == 0)
-		{
-			scanf("%lld %lld %lld", &p, &q, &v);
-			update(segtree, lazy, p - 1, q - 1, v, 0, n - 1, 0);
-		}
-		else
-		{
-			scanf("%lld %lld", &p, &q);
-			printf("%lld\n", query(segtree, lazy, p - 1, q - 1, 0, n - 1, 0));
-		}
-	}
-	return 0;
+    ll n, c;
+    scanf("%lld %lld", &n, &c);
+    ll arr[n] = {0}, p, q, v, choice;
+    ll segtree[MAX], lazy[MAX] = {0};
+    ConsTree(arr, segtree, 0, n - 1, 0);
+    while (c--)
+    {
+        scanf("%lld", &choice);
+        if (choice == 0)
+        {
+            scanf("%lld %lld %lld", &p, &q, &v);
+            update(segtree, lazy, p - 1, q - 1, v, 0, n - 1, 0);
+        }
+        else
+        {
+            scanf("%lld %lld", &p, &q);
+            printf("%lld\n", query(segtree, lazy, p - 1, q - 1, 0, n - 1, 0));
+        }
+    }
+    return 0;
 }
diff --git a/search/binary_search.cpp b/search/binary_search.cpp
index 66da31d7f..ba0ce7644 100644
--- a/search/binary_search.cpp
+++ b/search/binary_search.cpp
@@ -12,10 +12,12 @@
  * \returns index if T is found
  * \return -1 if T is not found
  */
-int binary_search(int a[], int r, int key) {
+int binary_search(int a[], int r, int key)
+{
     int l = 0;
 
-    while (l <= r) {
+    while (l <= r)
+    {
         int m = l + (r - l) / 2;
         if (key == a[m])
             return m;
@@ -28,7 +30,8 @@ int binary_search(int a[], int r, int key) {
 }
 
 /** main function */
-int main(int argc, char const* argv[]) {
+int main(int argc, char const* argv[])
+{
     int n, key;
     std::cout << "Enter size of array: ";
     std::cin >> n;
@@ -37,7 +40,8 @@ int main(int argc, char const* argv[]) {
     int* a = new int[n];
 
     // this loop use for store value in Array
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         std::cin >> a[i];
     }
 
diff --git a/search/exponential_search.cpp b/search/exponential_search.cpp
index f57cbf96b..276d03246 100644
--- a/search/exponential_search.cpp
+++ b/search/exponential_search.cpp
@@ -31,10 +31,12 @@
  * \returns `nullptr` if value not found
  */
 template <class Type>
-inline Type* binary_s(Type* array, size_t size, Type key) {
+inline Type* binary_s(Type* array, size_t size, Type key)
+{
     int32_t lower_index(0), upper_index(size - 1), middle_index;
 
-    while (lower_index <= upper_index) {
+    while (lower_index <= upper_index)
+    {
         middle_index = std::floor((lower_index + upper_index) / 2);
 
         if (*(array + middle_index) < key)
@@ -56,10 +58,13 @@ inline Type* binary_s(Type* array, size_t size, Type key) {
  * * Auxiliary Space Complexity O(1)
  */
 template <class Type>
-Type* struzik_search(Type* array, size_t size, Type key) {
+Type* struzik_search(Type* array, size_t size, Type key)
+{
     uint32_t block_front(0), block_size = size == 0 ? 0 : 1;
-    while (block_front != block_size) {
-        if (*(array + block_size - 1) < key) {
+    while (block_front != block_size)
+    {
+        if (*(array + block_size - 1) < key)
+        {
             block_front = block_size;
             (block_size * 2 - 1 < size) ? (block_size *= 2) : block_size = size;
             continue;
@@ -71,7 +76,8 @@ Type* struzik_search(Type* array, size_t size, Type key) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     // TEST CASES
     int* sorted_array = new int[7]{7, 10, 15, 23, 70, 105, 203};
     assert(struzik_search<int>(sorted_array, 7, 0) == nullptr);
diff --git a/search/hash_search.cpp b/search/hash_search.cpp
index 6e4caffc3..c417c114b 100644
--- a/search/hash_search.cpp
+++ b/search/hash_search.cpp
@@ -26,7 +26,8 @@ int data[MAX] = {1, 10, 15, 5, 8, 7};  //!< test data
 /**
  * a one-way linked list
  */
-typedef struct list {
+typedef struct list
+{
     int key;            //!< key value for node
     struct list* next;  //!< pointer to next link in the chain
 } node,                 /**< define node as one item list */
@@ -52,7 +53,8 @@ int h(int key) { return key % HASHMAX; }
  * \warning dynamic memory allocated to `n` never gets freed.
  * \todo fix memory leak
  */
-void create_list(int key) {  // Construct hash table
+void create_list(int key)
+{  // Construct hash table
     link p, n;
     int index;
     n = (link)malloc(sizeof(node));
@@ -60,10 +62,13 @@ void create_list(int key) {  // Construct hash table
     n->next = NULL;
     index = h(key);
     p = hashtab[index].next;
-    if (p != NULL) {
+    if (p != NULL)
+    {
         n->next = p;
         hashtab[index].next = n;
-    } else {
+    }
+    else
+    {
         hashtab[index].next = n;
     }
 }
@@ -73,7 +78,8 @@ void create_list(int key) {  // Construct hash table
  * (int key) function, then one-dimensional linear search. If found @return
  * element depth and number of searches If not found @return -1
  */
-int hash_search(int key, int* counter) {  // Hash lookup function
+int hash_search(int key, int* counter)
+{  // Hash lookup function
     link pointer;
     int index;
 
@@ -83,7 +89,8 @@ int hash_search(int key, int* counter) {  // Hash lookup function
 
     std::cout << "data[" << index << "]:";
 
-    while (pointer != NULL) {
+    while (pointer != NULL)
+    {
         counter[0]++;
         std::cout << "data[" << pointer->key << "]:";
         if (pointer->key == key)
@@ -96,23 +103,27 @@ int hash_search(int key, int* counter) {  // Hash lookup function
 }
 
 /** main function */
-int main() {
+int main()
+{
     link p;
     int key, index, i, counter;  // Key is the value to be found
     index = 0;
 
     // You can write the input mode here
-    while (index < MAX) {  // Construct hash table
+    while (index < MAX)
+    {  // Construct hash table
         create_list(data[index]);
         index++;
     }
 
-    for (i = 0; i < HASHMAX; i++) {  // Output hash table
+    for (i = 0; i < HASHMAX; i++)
+    {  // Output hash table
         std::cout << "hashtab [" << i << "]\n";
 
         p = hashtab[i].next;
 
-        while (p != NULL) {
+        while (p != NULL)
+        {
             std::cout << "please int key:";
             if (p->key > 0)
                 std::cout << "[" << p->key << "]";
@@ -121,7 +132,8 @@ int main() {
         std::cout << std::endl;
     }
 
-    while (key != -1) {
+    while (key != -1)
+    {
         // You can write the input mode here
         // test key = 10
         key = 10;
diff --git a/search/interpolation_search.cpp b/search/interpolation_search.cpp
index 4339dc366..0b356b119 100644
--- a/search/interpolation_search.cpp
+++ b/search/interpolation_search.cpp
@@ -12,11 +12,13 @@
  * \returns index where the value is found
  * \returns 0 if not found
  */
-int interpolation_search(int arr[], int value, int len) {
+int interpolation_search(int arr[], int value, int len)
+{
     int low = 0, high, mid;
     high = len - 1;
 
-    while (arr[low] <= value && arr[high] >= value) {
+    while (arr[low] <= value && arr[high] >= value)
+    {
         mid = (low +
                ((value - arr[low]) * (high - low)) / (arr[high] - arr[low]));
         if (arr[mid] > value)
@@ -34,7 +36,8 @@ int interpolation_search(int arr[], int value, int len) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     int n, value, re;
 
     std::cout << "Enter the size of array(less than 100) : ";
diff --git a/search/interpolation_search2.cpp b/search/interpolation_search2.cpp
index 93fa6cd83..9400c5f96 100644
--- a/search/interpolation_search2.cpp
+++ b/search/interpolation_search2.cpp
@@ -12,10 +12,12 @@
  * \returns index where the value is found
  * \returns -1 if not found
  */
-int InterpolationSearch(int A[], int n, int x) {
+int InterpolationSearch(int A[], int n, int x)
+{
     int low = 0;
     int high = n - 1;
-    while (low <= high) {
+    while (low <= high)
+    {
         int mid = low + (((high - 1) * (x - A[low])) / (A[high] - A[low]));
         if (x == A[mid])
             return mid;  // Found x, return (exit)
@@ -29,7 +31,8 @@ int InterpolationSearch(int A[], int n, int x) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     int A[] = {2, 4, 5, 7, 13, 14, 15, 23};
     int x = 17;
 
diff --git a/search/jump_search.cpp b/search/jump_search.cpp
index f7b100a4e..b854ac6f9 100644
--- a/search/jump_search.cpp
+++ b/search/jump_search.cpp
@@ -9,14 +9,16 @@
 
 /** jump search implementation
  */
-int jumpSearch(int arr[], int x, int n) {
+int jumpSearch(int arr[], int x, int n)
+{
     // Finding block size to be jumped
     int step = std::sqrt(n);
 
     // Finding the block where element is
     // present (if it is present)
     int prev = 0;
-    while (arr[std::min(step, n) - 1] < x) {
+    while (arr[std::min(step, n) - 1] < x)
+    {
         prev = step;
         step += std::sqrt(n);
         if (prev >= n)
@@ -25,7 +27,8 @@ int jumpSearch(int arr[], int x, int n) {
 
     // Doing a linear search for x in block
     // beginning with prev.
-    while (arr[prev] < x) {
+    while (arr[prev] < x)
+    {
         prev++;
 
         // If we reached next block or end of
@@ -41,7 +44,8 @@ int jumpSearch(int arr[], int x, int n) {
 }
 
 // Driver program to test function
-int main() {
+int main()
+{
     int arr[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610};
     int x = 55;
     int n = sizeof(arr) / sizeof(arr[0]);
diff --git a/search/linear_search.cpp b/search/linear_search.cpp
index 142506951..b8fd798a7 100644
--- a/search/linear_search.cpp
+++ b/search/linear_search.cpp
@@ -13,9 +13,12 @@
  * \returns index where the key-value occurs in the array
  * \returns -1 if key-value not found
  */
-int LinearSearch(int *array, int size, int key) {
-    for (int i = 0; i < size; ++i) {
-        if (array[i] == key) {
+int LinearSearch(int *array, int size, int key)
+{
+    for (int i = 0; i < size; ++i)
+    {
+        if (array[i] == key)
+        {
             return i;
         }
     }
@@ -24,7 +27,8 @@ int LinearSearch(int *array, int size, int key) {
 }
 
 /** main function */
-int main() {
+int main()
+{
     int size;
     std::cout << "\nEnter the size of the Array : ";
     std::cin >> size;
@@ -34,7 +38,8 @@ int main() {
 
     // Input array
     std::cout << "\nEnter the Array of " << size << " numbers : ";
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++)
+    {
         std::cin >> array[i];
     }
 
@@ -42,9 +47,12 @@ int main() {
     std::cin >> key;
 
     int index = LinearSearch(array, size, key);
-    if (index != -1) {
+    if (index != -1)
+    {
         std::cout << "\nNumber found at index : " << index;
-    } else {
+    }
+    else
+    {
         std::cout << "\nNot found";
     }
 
diff --git a/search/median_search.cpp b/search/median_search.cpp
index 7379cad26..433ffc1f7 100644
--- a/search/median_search.cpp
+++ b/search/median_search.cpp
@@ -14,18 +14,25 @@
  * @todo add documentation
  */
 template <class X>
-void comp(X x, std::vector<int> *s1, std::vector<int> *s2,
-          std::vector<int> *s3) {
-    if (s1->size() >= x && s1->size() + s2->size() < x) {
+void comp(X x, std::vector<int> *s1, std::vector<int> *s2, std::vector<int> *s3)
+{
+    if (s1->size() >= x && s1->size() + s2->size() < x)
+    {
         std::cout << (*s2)[0] << " is the " << x + 1 << "th element from front";
-    } else if (s1->size() > x) {
+    }
+    else if (s1->size() > x)
+    {
         std::sort(s1->begin(), s1->end());
         std::cout << (*s1)[x] << " is the " << x + 1 << "th element from front";
-    } else if (s1->size() + s2->size() <= x && s3->size() > x) {
+    }
+    else if (s1->size() + s2->size() <= x && s3->size() > x)
+    {
         std::sort(s3->begin(), s3->end());
         std::cout << (*s3)[x - s1->size() - s2->size()] << " is the " << x + 1
                   << "th element from front";
-    } else {
+    }
+    else
+    {
         std::cout << x + 1 << " is invalid location";
     }
 }
@@ -35,7 +42,8 @@ void comp(X x, std::vector<int> *s1, std::vector<int> *s2,
 /**
  * Main function
  */
-int main() {
+int main()
+{
     std::vector<int> v{25, 21, 98, 100, 76, 22, 43, 60, 89, 87};
     std::vector<int> s1;
     std::vector<int> s2;
@@ -54,14 +62,20 @@ int main() {
     std::cout << "\nmedian=" << median << std::endl;
     int avg1, avg2, avg3, sum1 = 0, sum2 = 0, sum3 = 0;
 
-    for (int i = 0; i < v.size(); i++) {  // iterate through all numbers
-        if (v.back() == v[median]) {
+    for (int i = 0; i < v.size(); i++)
+    {  // iterate through all numbers
+        if (v.back() == v[median])
+        {
             avg1 = sum1 + v.back();
             s2.push_back(v.back());
-        } else if (v.back() < v[median]) {
+        }
+        else if (v.back() < v[median])
+        {
             avg2 = sum2 + v.back();
             s1.push_back(v.back());
-        } else {
+        }
+        else
+        {
             avg3 = sum3 + v.back();
             s3.push_back(v.back());
         }
diff --git a/search/ternary_search.cpp b/search/ternary_search.cpp
index 73b89da7a..f1e2eccf0 100644
--- a/search/ternary_search.cpp
+++ b/search/ternary_search.cpp
@@ -45,10 +45,14 @@ void get_input() {}
  * \returns index where the target value was found
  * \returns -1 if target value not found
  */
-int it_ternary_search(int left, int right, int A[], int target) {
-    while (1) {
-        if (left < right) {
-            if (right - left < absolutePrecision) {
+int it_ternary_search(int left, int right, int A[], int target)
+{
+    while (1)
+    {
+        if (left < right)
+        {
+            if (right - left < absolutePrecision)
+            {
                 for (int i = left; i <= right; i++)
                     if (A[i] == target)
                         return i;
@@ -71,7 +75,9 @@ int it_ternary_search(int left, int right, int A[], int target) {
 
             else
                 left = oneThird + 1, right = twoThird - 1;
-        } else {
+        }
+        else
+        {
             return -1;
         }
     }
@@ -87,9 +93,12 @@ int it_ternary_search(int left, int right, int A[], int target) {
  * \returns index where the target value was found
  * \returns -1 if target value not found
  */
-int rec_ternary_search(int left, int right, int A[], int target) {
-    if (left < right) {
-        if (right - left < absolutePrecision) {
+int rec_ternary_search(int left, int right, int A[], int target)
+{
+    if (left < right)
+    {
+        if (right - left < absolutePrecision)
+        {
             for (int i = left; i <= right; i++)
                 if (A[i] == target)
                     return i;
@@ -111,7 +120,9 @@ int rec_ternary_search(int left, int right, int A[], int target) {
             return rec_ternary_search(twoThird + 1, right, A, target);
 
         return rec_ternary_search(oneThird + 1, twoThird - 1, A, target);
-    } else {
+    }
+    else
+    {
         return -1;
     }
 }
@@ -124,14 +135,16 @@ int rec_ternary_search(int left, int right, int A[], int target) {
  * \param[in] A array to search in
  * \param[in] target value to search for
  */
-void ternary_search(int N, int A[], int target) {
+void ternary_search(int N, int A[], int target)
+{
     std::cout << it_ternary_search(0, N - 1, A, target) << '\t';
     std::cout << rec_ternary_search(0, N - 1, A, target) << '\t';
     std::cout << std::endl;
 }
 
 /** Main function */
-int main() {
+int main()
+{
     int N = 21;
     int A[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 10};
     get_input();
diff --git a/search/text_search.cpp b/search/text_search.cpp
index ee66a506a..a228d23b2 100644
--- a/search/text_search.cpp
+++ b/search/text_search.cpp
@@ -12,7 +12,8 @@
 
 /** Main function
  */
-int main() {
+int main()
+{
     std::string paragraph;
     std::cout << "Please enter your paragraph: \n";
     std::getline(std::cin, paragraph);
@@ -20,18 +21,25 @@ int main() {
     std::cout << "\nThe size of your paragraph = " << paragraph.size()
               << " characters. \n\n";
 
-    if (paragraph.empty()) {
+    if (paragraph.empty())
+    {
         std::cout << "\nThe paragraph is empty" << std::endl;
-    } else {
-        while (true) {
+    }
+    else
+    {
+        while (true)
+        {
             std::string word;
             std::cout << "Please enter the word you are searching for: ";
             std::getline(std::cin, word);
             std::cout << "Hello, your word is " << word << "!\n";
-            if (paragraph.find(word) == std::string::npos) {
+            if (paragraph.find(word) == std::string::npos)
+            {
                 std::cout << word << " does not exist in the sentence"
                           << std::endl;
-            } else {
+            }
+            else
+            {
                 std::cout << "The word " << word << " is now found at location "
                           << paragraph.find(word) << std::endl
                           << std::endl;
diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
index a1a54c1e0..0215fc769 100644
--- a/sorting/bead_sort.cpp
+++ b/sorting/bead_sort.cpp
@@ -5,11 +5,13 @@
 #define BEAD(i, j) beads[i * max + j]
 
 // function to perform the above algorithm
-void beadSort(int *a, int len) {
+void beadSort(int *a, int len)
+{
     // Find the maximum element
     int max = a[0];
     for (int i = 1; i < len; i++)
-        if (a[i] > max) max = a[i];
+        if (a[i] > max)
+            max = a[i];
 
     // allocating memory
     unsigned char *beads = new unsigned char[max * len];
@@ -19,10 +21,12 @@ void beadSort(int *a, int len) {
     for (int i = 0; i < len; i++)
         for (int j = 0; j < a[i]; j++) BEAD(i, j) = 1;
 
-    for (int j = 0; j < max; j++) {
+    for (int j = 0; j < max; j++)
+    {
         // count how many beads are on each post
         int sum = 0;
-        for (int i = 0; i < len; i++) {
+        for (int i = 0; i < len; i++)
+        {
             sum += BEAD(i, j);
             BEAD(i, j) = 0;
         }
@@ -32,9 +36,11 @@ void beadSort(int *a, int len) {
     }
 
     // Put sorted values in array using beads
-    for (int i = 0; i < len; i++) {
+    for (int i = 0; i < len; i++)
+    {
         int j;
-        for (j = 0; j < max && BEAD(i, j); j++) {
+        for (j = 0; j < max && BEAD(i, j); j++)
+        {
         }
 
         a[i] = j;
@@ -43,7 +49,8 @@ void beadSort(int *a, int len) {
 }
 
 // driver function to test the algorithm
-int main() {
+int main()
+{
     int a[] = {5, 3, 1, 7, 4, 1, 1, 20};
     int len = sizeof(a) / sizeof(a[0]);
 
diff --git a/sorting/bitonic_sort.cpp b/sorting/bitonic_sort.cpp
index 4d0981056..7f47cbac6 100644
--- a/sorting/bitonic_sort.cpp
+++ b/sorting/bitonic_sort.cpp
@@ -9,16 +9,20 @@
 /*The parameter dir indicates the sorting direction, ASCENDING
    or DESCENDING; if (a[i] > a[j]) agrees with the direction,
    then a[i] and a[j] are interchanged.*/
-void compAndSwap(int a[], int i, int j, int dir) {
-    if (dir == (a[i] > a[j])) std::swap(a[i], a[j]);
+void compAndSwap(int a[], int i, int j, int dir)
+{
+    if (dir == (a[i] > a[j]))
+        std::swap(a[i], a[j]);
 }
 
 /*It recursively sorts a bitonic sequence in ascending order,
   if dir = 1, and in descending order otherwise (means dir=0).
   The sequence to be sorted starts at index position low,
   the parameter cnt is the number of elements to be sorted.*/
-void bitonicMerge(int a[], int low, int cnt, int dir) {
-    if (cnt > 1) {
+void bitonicMerge(int a[], int low, int cnt, int dir)
+{
+    if (cnt > 1)
+    {
         int k = cnt / 2;
         for (int i = low; i < low + k; i++) compAndSwap(a, i, i + k, dir);
         bitonicMerge(a, low, k, dir);
@@ -29,8 +33,10 @@ void bitonicMerge(int a[], int low, int cnt, int dir) {
 /* This function first produces a bitonic sequence by recursively
     sorting its two halves in opposite sorting orders, and then
     calls bitonicMerge to make them in the same order */
-void bitonicSort(int a[], int low, int cnt, int dir) {
-    if (cnt > 1) {
+void bitonicSort(int a[], int low, int cnt, int dir)
+{
+    if (cnt > 1)
+    {
         int k = cnt / 2;
 
         // sort in ascending order since dir here is 1
@@ -50,7 +56,8 @@ void bitonicSort(int a[], int low, int cnt, int dir) {
 void sort(int a[], int N, int up) { bitonicSort(a, 0, N, up); }
 
 // Driver code
-int main() {
+int main()
+{
     int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
     int N = sizeof(a) / sizeof(a[0]);
 
diff --git a/sorting/bubble_sort.cpp b/sorting/bubble_sort.cpp
index c43e425fc..8d2a33dcd 100644
--- a/sorting/bubble_sort.cpp
+++ b/sorting/bubble_sort.cpp
@@ -40,7 +40,8 @@ optimized bubble sort algorithm. It's right down there.
 #include <iostream>
 #include <vector>
 
-int main() {
+int main()
+{
     int n;
     bool swap_check = true;
     std::cout << "Enter the amount of numbers to sort: ";
@@ -50,16 +51,20 @@ int main() {
     int num;
 
     // Input
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         std::cin >> num;
         numbers.push_back(num);
     }
 
     // Bubble Sorting
-    for (int i = 0; (i < n) && (swap_check); i++) {
+    for (int i = 0; (i < n) && (swap_check); i++)
+    {
         swap_check = false;
-        for (int j = 0; j < n - 1 - i; j++) {
-            if (numbers[j] > numbers[j + 1]) {
+        for (int j = 0; j < n - 1 - i; j++)
+        {
+            if (numbers[j] > numbers[j + 1])
+            {
                 swap_check = true;
                 std::swap(numbers[j],
                           numbers[j + 1]);  // by changing swap location.
@@ -72,10 +77,14 @@ int main() {
 
     // Output
     std::cout << "\nSorted Array : ";
-    for (int i = 0; i < numbers.size(); i++) {
-        if (i != numbers.size() - 1) {
+    for (int i = 0; i < numbers.size(); i++)
+    {
+        if (i != numbers.size() - 1)
+        {
             std::cout << numbers[i] << ", ";
-        } else {
+        }
+        else
+        {
             std::cout << numbers[i] << std::endl;
         }
     }
diff --git a/sorting/bucket_sort.cpp b/sorting/bucket_sort.cpp
index c43865281..ee945627c 100644
--- a/sorting/bucket_sort.cpp
+++ b/sorting/bucket_sort.cpp
@@ -4,12 +4,14 @@
 #include <vector>
 
 // Function to sort arr[] of size n using bucket sort
-void bucketSort(float arr[], int n) {
+void bucketSort(float arr[], int n)
+{
     // 1) Create n empty buckets
     std::vector<float> *b = new std::vector<float>[n];
 
     // 2) Put array elements in different buckets
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         int bi = n * arr[i];  // Index in bucket
         b[bi].push_back(arr[i]);
     }
@@ -25,7 +27,8 @@ void bucketSort(float arr[], int n) {
 }
 
 /* Driver program to test above funtion */
-int main() {
+int main()
+{
     float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
     int n = sizeof(arr) / sizeof(arr[0]);
     bucketSort(arr, n);
diff --git a/sorting/cocktail_selection_sort.cpp b/sorting/cocktail_selection_sort.cpp
index ab6229996..ef3d30752 100644
--- a/sorting/cocktail_selection_sort.cpp
+++ b/sorting/cocktail_selection_sort.cpp
@@ -9,27 +9,35 @@
 
 // Iterative Version
 
-void CocktailSelectionSort(std::vector<int> *vec, int low, int high) {
-    while (low <= high) {
+void CocktailSelectionSort(std::vector<int> *vec, int low, int high)
+{
+    while (low <= high)
+    {
         int minimum = (*vec)[low];
         int minimumindex = low;
         int maximum = (*vec)[high];
         int maximumindex = high;
 
-        for (int i = low; i <= high; i++) {
-            if ((*vec)[i] >= maximum) {
+        for (int i = low; i <= high; i++)
+        {
+            if ((*vec)[i] >= maximum)
+            {
                 maximum = (*vec)[i];
                 maximumindex = i;
             }
-            if ((*vec)[i] <= minimum) {
+            if ((*vec)[i] <= minimum)
+            {
                 minimum = (*vec)[i];
                 minimumindex = i;
             }
         }
-        if (low != maximumindex || high != minimumindex) {
+        if (low != maximumindex || high != minimumindex)
+        {
             std::swap((*vec)[low], (*vec)[minimumindex]);
             std::swap((*vec)[high], (*vec)[maximumindex]);
-        } else {
+        }
+        else
+        {
             std::swap((*vec)[low], (*vec)[high]);
         }
 
@@ -40,28 +48,36 @@ void CocktailSelectionSort(std::vector<int> *vec, int low, int high) {
 
 // Recursive Version
 
-void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high) {
-    if (low >= high) return;
+void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high)
+{
+    if (low >= high)
+        return;
 
     int minimum = (*vec)[low];
     int minimumindex = low;
     int maximum = (*vec)[high];
     int maximumindex = high;
 
-    for (int i = low; i <= high; i++) {
-        if ((*vec)[i] >= maximum) {
+    for (int i = low; i <= high; i++)
+    {
+        if ((*vec)[i] >= maximum)
+        {
             maximum = (*vec)[i];
             maximumindex = i;
         }
-        if ((*vec)[i] <= minimum) {
+        if ((*vec)[i] <= minimum)
+        {
             minimum = (*vec)[i];
             minimumindex = i;
         }
     }
-    if (low != maximumindex || high != minimumindex) {
+    if (low != maximumindex || high != minimumindex)
+    {
         std::swap((*vec)[low], (*vec)[minimumindex]);
         std::swap((*vec)[high], (*vec)[maximumindex]);
-    } else {
+    }
+    else
+    {
         std::swap((*vec)[low], (*vec)[high]);
     }
 
@@ -70,13 +86,15 @@ void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high) {
 
 // main function, select any one of iterative or recursive version
 
-int main() {
+int main()
+{
     int n;
     std::cout << "Enter number of elements\n";
     std::cin >> n;
     std::vector<int> v(n);
     std::cout << "Enter all the elements\n";
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i)
+    {
         std::cin >> v[i];
     }
 
@@ -84,16 +102,22 @@ int main() {
     std::cout << "Enter method: \n\t0: iterative\n\t1: recursive:\t";
     std::cin >> method;
 
-    if (method == 0) {
+    if (method == 0)
+    {
         CocktailSelectionSort(&v, 0, n - 1);
-    } else if (method == 1) {
+    }
+    else if (method == 1)
+    {
         CocktailSelectionSort_v2(&v, 0, n - 1);
-    } else {
+    }
+    else
+    {
         std::cerr << "Unknown method" << std::endl;
         return -1;
     }
     std::cout << "Sorted elements are\n";
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i)
+    {
         std::cout << v[i] << " ";
     }
 
diff --git a/sorting/comb_sort.cpp b/sorting/comb_sort.cpp
index 1b0a4d706..d554ac757 100644
--- a/sorting/comb_sort.cpp
+++ b/sorting/comb_sort.cpp
@@ -8,13 +8,15 @@
 int a[100005];
 int n;
 
-int FindNextGap(int x) {
+int FindNextGap(int x)
+{
     x = (x * 10) / 13;
 
     return std::max(1, x);
 }
 
-void CombSort(int a[], int l, int r) {
+void CombSort(int a[], int l, int r)
+{
     // Init gap
     int gap = n;
 
@@ -22,15 +24,18 @@ void CombSort(int a[], int l, int r) {
     bool swapped = true;
 
     // Keep running until gap = 1 or none elements were swapped
-    while (gap != 1 || swapped) {
+    while (gap != 1 || swapped)
+    {
         // Find next gap
         gap = FindNextGap(gap);
 
         swapped = false;
 
         // Compare all elements with current gap
-        for (int i = l; i <= r - gap; ++i) {
-            if (a[i] > a[i + gap]) {
+        for (int i = l; i <= r - gap; ++i)
+        {
+            if (a[i] > a[i + gap])
+            {
                 std::swap(a[i], a[i + gap]);
                 swapped = true;
             }
@@ -38,7 +43,8 @@ void CombSort(int a[], int l, int r) {
     }
 }
 
-int main() {
+int main()
+{
     std::cin >> n;
     for (int i = 1; i <= n; ++i) std::cin >> a[i];
 
diff --git a/sorting/counting_sort.cpp b/sorting/counting_sort.cpp
index bda37bbd8..9dadd48cc 100644
--- a/sorting/counting_sort.cpp
+++ b/sorting/counting_sort.cpp
@@ -3,64 +3,61 @@ using namespace std;
 
 int Max(int Arr[], int N)
 {
-	int max = Arr[0];
-	for (int i = 1; i < N; i++)
-		if (Arr[i] > max)
-			max = Arr[i];
-	return max;
+    int max = Arr[0];
+    for (int i = 1; i < N; i++)
+        if (Arr[i] > max)
+            max = Arr[i];
+    return max;
 }
 
 int Min(int Arr[], int N)
 {
-	int min = Arr[0];
-	for (int i = 1; i < N; i++)
-		if (Arr[i] < min)
-			min = Arr[i];
-	return min;
+    int min = Arr[0];
+    for (int i = 1; i < N; i++)
+        if (Arr[i] < min)
+            min = Arr[i];
+    return min;
 }
 
 void Print(int Arr[], int N)
 {
-	for (int i = 0; i < N; i++)
-		cout << Arr[i] << ", ";
+    for (int i = 0; i < N; i++) cout << Arr[i] << ", ";
 }
 
 int *Counting_Sort(int Arr[], int N)
 {
+    int max = Max(Arr, N);
+    int min = Min(Arr, N);
+    int *Sorted_Arr = new int[N];
 
-	int max = Max(Arr, N);
-	int min = Min(Arr, N);
-	int *Sorted_Arr = new int[N];
+    int *Count = new int[max - min + 1];
 
-	int *Count = new int[max - min + 1];
+    for (int i = 0; i < N; i++) Count[Arr[i] - min]++;
 
-	for (int i = 0; i < N; i++)
-		Count[Arr[i] - min]++;
+    for (int i = 1; i < (max - min + 1); i++) Count[i] += Count[i - 1];
 
-	for (int i = 1; i < (max - min + 1); i++)
-		Count[i] += Count[i - 1];
+    for (int i = N - 1; i >= 0; i--)
+    {
+        Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
+        Count[Arr[i] - min]--;
+    }
 
-	for (int i = N - 1; i >= 0; i--)
-	{
-		Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
-		Count[Arr[i] - min]--;
-	}
-
-	return Sorted_Arr;
+    return Sorted_Arr;
 }
 
 int main()
 {
+    int Arr[] = {47, 65, 20, 66, 25, 53, 64, 69, 72, 22,
+                 74, 25, 53, 15, 42, 36, 4,  69, 86, 19},
+        N = 20;
+    int *Sorted_Arr;
 
-	int Arr[] = {47, 65, 20, 66, 25, 53, 64, 69, 72, 22, 74, 25, 53, 15, 42, 36, 4, 69, 86, 19}, N = 20;
-	int *Sorted_Arr;
+    cout << "\n\tOrignal Array = ";
+    Print(Arr, N);
+    Sorted_Arr = Counting_Sort(Arr, N);
+    cout << "\n\t Sorted Array = ";
+    Print(Sorted_Arr, N);
+    cout << endl;
 
-	cout << "\n\tOrignal Array = ";
-	Print(Arr, N);
-	Sorted_Arr = Counting_Sort(Arr, N);
-	cout << "\n\t Sorted Array = ";
-	Print(Sorted_Arr, N);
-	cout << endl;
-
-	return 0;
+    return 0;
 }
diff --git a/sorting/counting_sort_string.cpp b/sorting/counting_sort_string.cpp
index 6179e5d11..77e8cdf89 100644
--- a/sorting/counting_sort_string.cpp
+++ b/sorting/counting_sort_string.cpp
@@ -5,18 +5,14 @@ using namespace std;
 
 void countSort(string arr)
 {
-
     string output;
 
     int count[256], i;
-    for (int i = 0; i < 256; i++)
-        count[i] = 0;
+    for (int i = 0; i < 256; i++) count[i] = 0;
 
-    for (i = 0; arr[i]; ++i)
-        ++count[arr[i]];
+    for (i = 0; arr[i]; ++i) ++count[arr[i]];
 
-    for (i = 1; i <= 256; ++i)
-        count[i] += count[i - 1];
+    for (i = 1; i <= 256; ++i) count[i] += count[i - 1];
 
     for (i = 0; arr[i]; ++i)
     {
@@ -24,8 +20,7 @@ void countSort(string arr)
         --count[arr[i]];
     }
 
-    for (i = 0; arr[i]; ++i)
-        arr[i] = output[i];
+    for (i = 0; arr[i]; ++i) arr[i] = output[i];
 
     cout << "Sorted character array is " << arr;
 }
diff --git a/sorting/heap_sort.cpp b/sorting/heap_sort.cpp
index 9948bb821..b9b62a5f6 100644
--- a/sorting/heap_sort.cpp
+++ b/sorting/heap_sort.cpp
@@ -1,7 +1,8 @@
 #include <algorithm>
 #include <iostream>
 
-void heapify(int *a, int i, int n) {
+void heapify(int *a, int i, int n)
+{
     int largest = i;
     const int l = 2 * i + 1;
     const int r = 2 * i + 2;
@@ -12,31 +13,38 @@ void heapify(int *a, int i, int n) {
     if (r < n && a[r] > a[largest])
         largest = r;
 
-    if (largest != i) {
+    if (largest != i)
+    {
         std::swap(a[i], a[largest]);
         heapify(a, n, largest);
     }
 }
 
-void heapsort(int *a, int n) {
-    for (int i = n - 1; i >= 0; --i) {
+void heapsort(int *a, int n)
+{
+    for (int i = n - 1; i >= 0; --i)
+    {
         std::swap(a[0], a[i]);
         heapify(a, 0, i);
     }
 }
 
-void build_maxheap(int *a, int n) {
-    for (int i = n / 2 - 1; i >= 0; --i) {
+void build_maxheap(int *a, int n)
+{
+    for (int i = n / 2 - 1; i >= 0; --i)
+    {
         heapify(a, i, n);
     }
 }
 
-int main() {
+int main()
+{
     int n;
     std::cout << "Enter number of elements of array\n";
     std::cin >> n;
     int a[20];
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i)
+    {
         std::cout << "Enter Element " << i << std::endl;
         std::cin >> a[i];
     }
@@ -44,7 +52,8 @@ int main() {
     build_maxheap(a, n);
     heapsort(a, n);
     std::cout << "Sorted Output\n";
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i)
+    {
         std::cout << a[i] << std::endl;
     }
 
diff --git a/sorting/insertion_sort.cpp b/sorting/insertion_sort.cpp
index fe920ca59..b96a44c47 100644
--- a/sorting/insertion_sort.cpp
+++ b/sorting/insertion_sort.cpp
@@ -2,7 +2,8 @@
 
 #include <iostream>
 
-int main() {
+int main()
+{
     int n;
     std::cout << "\nEnter the length of your array : ";
     std::cin >> n;
@@ -10,15 +11,18 @@ int main() {
     std::cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
 
     // Input
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         std::cin >> Array[i];
     }
 
     // Sorting
-    for (int i = 1; i < n; i++) {
+    for (int i = 1; i < n; i++)
+    {
         int temp = Array[i];
         int j = i - 1;
-        while (j >= 0 && temp < Array[j]) {
+        while (j >= 0 && temp < Array[j])
+        {
             Array[j + 1] = Array[j];
             j--;
         }
@@ -27,7 +31,8 @@ int main() {
 
     // Output
     std::cout << "\nSorted Array : ";
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         std::cout << Array[i] << "\t";
     }
 
diff --git a/sorting/library_sort.cpp b/sorting/library_sort.cpp
index 6f1ab6245..c0fa857e7 100644
--- a/sorting/library_sort.cpp
+++ b/sorting/library_sort.cpp
@@ -1,15 +1,15 @@
 #include <algorithm>
 #include <iostream>
 
-void librarySort(int *index, int n) {
+void librarySort(int *index, int n)
+{
     int lib_size, index_pos,
         *gaps,        // gaps
         *library[2];  // libraries
 
     bool target_lib, *numbered;
 
-    for (int i = 0; i < 2; i++)
-        library[i] = new int[n];
+    for (int i = 0; i < 2; i++) library[i] = new int[n];
 
     gaps = new int[n + 1];
     numbered = new bool[n + 1];
@@ -19,7 +19,8 @@ void librarySort(int *index, int n) {
     target_lib = 0;
     library[target_lib][0] = index[0];
 
-    while (index_pos < n) {
+    while (index_pos < n)
+    {
         // binary search
         int insert = std::distance(
             library[target_lib],
@@ -28,19 +29,23 @@ void librarySort(int *index, int n) {
 
         // if there is no gap to insert a new index ...
 
-        if (numbered[insert] == true) {
+        if (numbered[insert] == true)
+        {
             int prov_size = 0, next_target_lib = !target_lib;
 
             // update library and clear gaps
 
-            for (int i = 0; i <= n; i++) {
-                if (numbered[i] == true) {
+            for (int i = 0; i <= n; i++)
+            {
+                if (numbered[i] == true)
+                {
                     library[next_target_lib][prov_size] = gaps[i];
                     prov_size++;
                     numbered[i] = false;
                 }
 
-                if (i <= lib_size) {
+                if (i <= lib_size)
+                {
                     library[next_target_lib][prov_size] =
                         library[target_lib][i];
                     prov_size++;
@@ -49,7 +54,9 @@ void librarySort(int *index, int n) {
 
             target_lib = next_target_lib;
             lib_size = prov_size - 1;
-        } else {
+        }
+        else
+        {
             numbered[insert] = true;
             gaps[insert] = index[index_pos];
             index_pos++;
@@ -57,14 +64,17 @@ void librarySort(int *index, int n) {
     }
 
     int index_pos_for_output = 0;
-    for (int i = 0; index_pos_for_output < n; i++) {
-        if (numbered[i] == true) {
+    for (int i = 0; index_pos_for_output < n; i++)
+    {
+        if (numbered[i] == true)
+        {
             // std::cout << gaps[i] << std::endl;
             index[index_pos_for_output] = gaps[i];
             index_pos_for_output++;
         }
 
-        if (i < lib_size) {
+        if (i < lib_size)
+        {
             // std::cout << library[target_lib][i] << std::endl;
             index[index_pos_for_output] = library[target_lib][i];
             index_pos_for_output++;
@@ -72,15 +82,15 @@ void librarySort(int *index, int n) {
     }
 }
 
-int main() {
+int main()
+{
     // ---example--
     int index_ex[] = {-6, 5, 9, 1, 9, 1, 0, 1, -8, 4, -12};
     int n_ex = sizeof(index_ex) / sizeof(index_ex[0]);
 
     librarySort(index_ex, n_ex);
     std::cout << "sorted array :" << std::endl;
-    for (int i = 0; i < n_ex; i++)
-        std::cout << index_ex[i] << " ";
+    for (int i = 0; i < n_ex; i++) std::cout << index_ex[i] << " ";
     std::cout << std::endl;
 
     /* --output--
diff --git a/sorting/merge_sort.cpp b/sorting/merge_sort.cpp
index 82ab869cd..1a394ded9 100644
--- a/sorting/merge_sort.cpp
+++ b/sorting/merge_sort.cpp
@@ -1,6 +1,7 @@
 #include <iostream>
 
-void merge(int arr[], int l, int m, int r) {
+void merge(int arr[], int l, int m, int r)
+{
     int i, j, k;
     int n1 = m - l + 1;
     int n2 = r - m;
@@ -13,24 +14,30 @@ void merge(int arr[], int l, int m, int r) {
     i = 0;
     j = 0;
     k = l;
-    while (i < n1 && j < n2) {
-        if (L[i] <= R[j]) {
+    while (i < n1 && j < n2)
+    {
+        if (L[i] <= R[j])
+        {
             arr[k] = L[i];
             i++;
-        } else {
+        }
+        else
+        {
             arr[k] = R[j];
             j++;
         }
         k++;
     }
 
-    while (i < n1) {
+    while (i < n1)
+    {
         arr[k] = L[i];
         i++;
         k++;
     }
 
-    while (j < n2) {
+    while (j < n2)
+    {
         arr[k] = R[j];
         j++;
         k++;
@@ -40,8 +47,10 @@ void merge(int arr[], int l, int m, int r) {
     delete[] R;
 }
 
-void mergeSort(int arr[], int l, int r) {
-    if (l < r) {
+void mergeSort(int arr[], int l, int r)
+{
+    if (l < r)
+    {
         int m = l + (r - l) / 2;
 
         mergeSort(arr, l, m);
@@ -51,12 +60,14 @@ void mergeSort(int arr[], int l, int r) {
     }
 }
 
-void show(int A[], int size) {
+void show(int A[], int size)
+{
     int i;
     for (i = 0; i < size; i++) std::cout << A[i] << "\n";
 }
 
-int main() {
+int main()
+{
     int size;
     std::cout << "\nEnter the number of elements : ";
 
@@ -66,7 +77,8 @@ int main() {
 
     std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i) {
+    for (int i = 0; i < size; ++i)
+    {
         std::cout << "\n";
         std::cin >> arr[i];
     }
diff --git a/sorting/non_recursive_merge_sort.cpp b/sorting/non_recursive_merge_sort.cpp
index 9d4e95f2f..9086ec0ed 100644
--- a/sorting/non_recursive_merge_sort.cpp
+++ b/sorting/non_recursive_merge_sort.cpp
@@ -22,17 +22,20 @@ void merge(Iterator, Iterator, const Iterator, char[]);
  */
 template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const Iterator last,
-                              const size_t n) {
+                              const size_t n)
+{
     // create a buffer large enough to store all elements
     // dynamically allocated to comply with cpplint
     char* buffer = new char[n * sizeof(*first)];
     // buffer size can be optimized to largest power of 2 less than n elements
     // divide the container into equally-sized segments whose length start at 1
     // and keeps increasing by factors of 2
-    for (size_t length(1); length < n; length <<= 1) {
+    for (size_t length(1); length < n; length <<= 1)
+    {
         // merge adjacent segments whose number is n / (length * 2)
         Iterator left(first);
-        for (size_t counter(n / (length << 1)); counter; --counter) {
+        for (size_t counter(n / (length << 1)); counter; --counter)
+        {
             Iterator right(left + length), end(right + length);
             merge(left, right, end, buffer);
             left = end;
@@ -53,7 +56,8 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
  * @param b points at the buffer
  */
 template <class Iterator>
-void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
+void merge(Iterator l, Iterator r, const Iterator e, char b[])
+{
     // create 2 pointers to point at the buffer
     auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
     // move the left part of the segment
@@ -73,7 +77,8 @@ void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
  * @param n the number of elements
  */
 template <class Iterator>
-void non_recursive_merge_sort(const Iterator first, const size_t n) {
+void non_recursive_merge_sort(const Iterator first, const size_t n)
+{
     non_recursive_merge_sort(first, first + n, n);
 }
 /// bottom-up merge sort which sorts elements in a non-decreasing order
@@ -82,16 +87,19 @@ void non_recursive_merge_sort(const Iterator first, const size_t n) {
  * @param last points to 1-step past the last element
  */
 template <class Iterator>
-void non_recursive_merge_sort(const Iterator first, const Iterator last) {
+void non_recursive_merge_sort(const Iterator first, const Iterator last)
+{
     non_recursive_merge_sort(first, last, last - first);
 }
 
-int main(int argc, char** argv) {
+int main(int argc, char** argv)
+{
     int size;
     std::cout << "Enter the number of elements : ";
     std::cin >> size;
     int* arr = new int[size];
-    for (int i = 0; i < size; ++i) {
+    for (int i = 0; i < size; ++i)
+    {
         std::cout << "arr[" << i << "] = ";
         std::cin >> arr[i];
     }
diff --git a/sorting/numeric_string_sort.cpp b/sorting/numeric_string_sort.cpp
index 8b86bb29d..358cc63e3 100644
--- a/sorting/numeric_string_sort.cpp
+++ b/sorting/numeric_string_sort.cpp
@@ -13,40 +13,48 @@
 #include <string>
 #include <vector>
 
-bool NumericSort(std::string a, std::string b) {
-    while (a[0] == '0') {
+bool NumericSort(std::string a, std::string b)
+{
+    while (a[0] == '0')
+    {
         a.erase(a.begin());
     }
-    while (b[0] == '0') {
+    while (b[0] == '0')
+    {
         b.erase(b.begin());
     }
     int n = a.length();
     int m = b.length();
-    if (n == m) return a < b;
+    if (n == m)
+        return a < b;
     return n < m;
 }
 
-int main() {
+int main()
+{
     int n;
     std::cout << "Enter number of elements to be sorted Numerically\n";
     std::cin >> n;
 
     std::vector<std::string> v(n);
     std::cout << "Enter the string of Numbers\n";
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         std::cin >> v[i];
     }
 
     sort(v.begin(), v.end());
     std::cout << "Elements sorted normally \n";
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         std::cout << v[i] << " ";
     }
     std::cout << "\n";
 
     std::sort(v.begin(), v.end(), NumericSort);
     std::cout << "Elements sorted Numerically \n";
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         std::cout << v[i] << " ";
     }
 
diff --git a/sorting/odd_even_sort.cpp b/sorting/odd_even_sort.cpp
index 62842c174..274f3033b 100644
--- a/sorting/odd_even_sort.cpp
+++ b/sorting/odd_even_sort.cpp
@@ -6,56 +6,55 @@ using namespace std;
 
 void oddEven(vector<int> &arr, int size)
 {
-	bool sorted = false;
-	while (!sorted)
-	{
-		sorted = true;
-		for (int i = 1; i < size - 1; i += 2) //Odd
-		{
-			if (arr[i] > arr[i + 1])
-			{
-				swap(arr[i], arr[i + 1]);
-				sorted = false;
-			}
-		}
+    bool sorted = false;
+    while (!sorted)
+    {
+        sorted = true;
+        for (int i = 1; i < size - 1; i += 2)  // Odd
+        {
+            if (arr[i] > arr[i + 1])
+            {
+                swap(arr[i], arr[i + 1]);
+                sorted = false;
+            }
+        }
 
-		for (int i = 0; i < size - 1; i += 2) //Even
-		{
-			if (arr[i] > arr[i + 1])
-			{
-				swap(arr[i], arr[i + 1]);
-				sorted = false;
-			}
-		}
-	}
+        for (int i = 0; i < size - 1; i += 2)  // Even
+        {
+            if (arr[i] > arr[i + 1])
+            {
+                swap(arr[i], arr[i + 1]);
+                sorted = false;
+            }
+        }
+    }
 }
 
 void show(vector<int> A, int size)
 {
-	int i;
-	for (i = 0; i < size; i++)
-		cout << A[i] << "\n";
+    int i;
+    for (i = 0; i < size; i++) cout << A[i] << "\n";
 }
 
 int main()
 {
-	int size, temp;
-	cout << "\nEnter the number of elements : ";
-	cin >> size;
+    int size, temp;
+    cout << "\nEnter the number of elements : ";
+    cin >> size;
 
-	vector<int> arr;
+    vector<int> arr;
 
-	cout << "\nEnter the unsorted elements : \n";
+    cout << "\nEnter the unsorted elements : \n";
 
-	for (int i = 0; i < size; ++i)
-	{
-		cin >> temp;
-		arr.push_back(temp);
-	}
+    for (int i = 0; i < size; ++i)
+    {
+        cin >> temp;
+        arr.push_back(temp);
+    }
 
-	oddEven(arr, size);
+    oddEven(arr, size);
 
-	cout << "Sorted array\n";
-	show(arr, size);
-	return 0;
+    cout << "Sorted array\n";
+    show(arr, size);
+    return 0;
 }
diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
index 1db6b014e..8bb376b24 100644
--- a/sorting/quick_sort.cpp
+++ b/sorting/quick_sort.cpp
@@ -33,14 +33,17 @@
  *
  */
 
-int partition(int arr[], int low, int high) {
+int partition(int arr[], int low, int high)
+{
     int pivot = arr[high];  // taking the last element as pivot
     int i = (low - 1);      // Index of smaller element
 
-    for (int j = low; j < high; j++) {
+    for (int j = low; j < high; j++)
+    {
         // If current element is smaller than or
         // equal to pivot
-        if (arr[j] <= pivot) {
+        if (arr[j] <= pivot)
+        {
             i++;  // increment index of smaller element
             int temp = arr[i];
             arr[i] = arr[j];
@@ -59,8 +62,10 @@ int partition(int arr[], int low, int high) {
  *      low --> Starting index,
  *      high --> Ending index
  */
-void quickSort(int arr[], int low, int high) {
-    if (low < high) {
+void quickSort(int arr[], int low, int high)
+{
+    if (low < high)
+    {
         int p = partition(arr, low, high);
         quickSort(arr, low, p - 1);
         quickSort(arr, p + 1, high);
@@ -68,13 +73,15 @@ void quickSort(int arr[], int low, int high) {
 }
 
 // prints the array after sorting
-void show(int arr[], int size) {
+void show(int arr[], int size)
+{
     for (int i = 0; i < size; i++) std::cout << arr[i] << " ";
     std::cout << "\n";
 }
 
 /** Driver program to test above functions */
-int main() {
+int main()
+{
     int size;
     std::cout << "\nEnter the number of elements : ";
 
@@ -84,7 +91,8 @@ int main() {
 
     std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i) {
+    for (int i = 0; i < size; ++i)
+    {
         std::cout << "\n";
         std::cin >> arr[i];
     }
diff --git a/sorting/radix_sort.cpp b/sorting/radix_sort.cpp
index a0fbfe99e..c3b5b1629 100644
--- a/sorting/radix_sort.cpp
+++ b/sorting/radix_sort.cpp
@@ -3,53 +3,66 @@
 #include <cstring>
 #include <iostream>
 
-void radixsort(int a[], int n) {
+void radixsort(int a[], int n)
+{
     int count[10];
     int* output = new int[n];
     memset(output, 0, n * sizeof(*output));
     memset(count, 0, sizeof(count));
     int max = 0;
-    for (int i = 0; i < n; ++i) {
-        if (a[i] > max) {
+    for (int i = 0; i < n; ++i)
+    {
+        if (a[i] > max)
+        {
             max = a[i];
         }
     }
     int maxdigits = 0;
-    while (max) {
+    while (max)
+    {
         maxdigits++;
         max /= 10;
     }
-    for (int j = 0; j < maxdigits; j++) {
-        for (int i = 0; i < n; i++) {
+    for (int j = 0; j < maxdigits; j++)
+    {
+        for (int i = 0; i < n; i++)
+        {
             int t = std::pow(10, j);
             count[(a[i] % (10 * t)) / t]++;
         }
         int k = 0;
-        for (int p = 0; p < 10; p++) {
-            for (int i = 0; i < n; i++) {
+        for (int p = 0; p < 10; p++)
+        {
+            for (int i = 0; i < n; i++)
+            {
                 int t = std::pow(10, j);
-                if ((a[i] % (10 * t)) / t == p) {
+                if ((a[i] % (10 * t)) / t == p)
+                {
                     output[k] = a[i];
                     k++;
                 }
             }
         }
         memset(count, 0, sizeof(count));
-        for (int i = 0; i < n; ++i) {
+        for (int i = 0; i < n; ++i)
+        {
             a[i] = output[i];
         }
     }
     delete[] output;
 }
 
-void print(int a[], int n) {
-    for (int i = 0; i < n; ++i) {
+void print(int a[], int n)
+{
+    for (int i = 0; i < n; ++i)
+    {
         std::cout << a[i] << " ";
     }
     std::cout << std::endl;
 }
 
-int main(int argc, char const* argv[]) {
+int main(int argc, char const* argv[])
+{
     int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
     int n = sizeof(a) / sizeof(a[0]);
     radixsort(a, n);
diff --git a/sorting/selection_sort.cpp b/sorting/selection_sort.cpp
index 5b8724141..7e8b0678c 100644
--- a/sorting/selection_sort.cpp
+++ b/sorting/selection_sort.cpp
@@ -1,39 +1,39 @@
-//Selection Sort
+// Selection Sort
 
 #include <iostream>
 using namespace std;
 
 int main()
 {
-	int Array[6];
-	cout << "\nEnter any 6 Numbers for Unsorted Array : ";
+    int Array[6];
+    cout << "\nEnter any 6 Numbers for Unsorted Array : ";
 
-	//Input
-	for (int i = 0; i < 6; i++)
-	{
-		cin >> Array[i];
-	}
+    // Input
+    for (int i = 0; i < 6; i++)
+    {
+        cin >> Array[i];
+    }
 
-	//Selection Sorting
-	for (int i = 0; i < 6; i++)
-	{
-		int min = i;
-		for (int j = i + 1; j < 6; j++)
-		{
-			if (Array[j] < Array[min])
-			{
-				min = j; //Finding the smallest number in Array
-			}
-		}
-		int temp = Array[i];
-		Array[i] = Array[min];
-		Array[min] = temp;
-	}
+    // Selection Sorting
+    for (int i = 0; i < 6; i++)
+    {
+        int min = i;
+        for (int j = i + 1; j < 6; j++)
+        {
+            if (Array[j] < Array[min])
+            {
+                min = j;  // Finding the smallest number in Array
+            }
+        }
+        int temp = Array[i];
+        Array[i] = Array[min];
+        Array[min] = temp;
+    }
 
-	//Output
-	cout << "\nSorted Array : ";
-	for (int i = 0; i < 6; i++)
-	{
-		cout << Array[i] << "\t";
-	}
+    // Output
+    cout << "\nSorted Array : ";
+    for (int i = 0; i < 6; i++)
+    {
+        cout << Array[i] << "\t";
+    }
 }
diff --git a/sorting/shell_sort.cpp b/sorting/shell_sort.cpp
index eb701478d..af783eb24 100644
--- a/sorting/shell_sort.cpp
+++ b/sorting/shell_sort.cpp
@@ -1,23 +1,31 @@
 #include <iostream>
 
-int main() {
+int main()
+{
     int size = 10;
     int* array = new int[size];
     // Input
     std::cout << "\nHow many numbers do want to enter in unsorted array : ";
     std::cin >> size;
     std::cout << "\nEnter the numbers for unsorted array : ";
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++)
+    {
         std::cin >> array[i];
     }
 
     // Sorting
-    for (int i = size / 2; i > 0; i = i / 2) {
-        for (int j = i; j < size; j++) {
-            for (int k = j - i; k >= 0; k = k - i) {
-                if (array[k] < array[k + i]) {
+    for (int i = size / 2; i > 0; i = i / 2)
+    {
+        for (int j = i; j < size; j++)
+        {
+            for (int k = j - i; k >= 0; k = k - i)
+            {
+                if (array[k] < array[k + i])
+                {
                     break;
-                } else {
+                }
+                else
+                {
                     int temp = array[k + i];
                     array[k + i] = array[k];
                     array[k] = temp;
@@ -28,7 +36,8 @@ int main() {
 
     // Output
     std::cout << "\nSorted array : ";
-    for (int i = 0; i < size; ++i) {
+    for (int i = 0; i < size; ++i)
+    {
         std::cout << array[i] << "\t";
     }
 
diff --git a/sorting/shell_sort2.cpp b/sorting/shell_sort2.cpp
index 1268c7a50..dee8cecd7 100644
--- a/sorting/shell_sort2.cpp
+++ b/sorting/shell_sort2.cpp
@@ -6,100 +6,113 @@
 // for std::swap
 #include <utility>
 
-template <class T> void show_data(T *arr, size_t LEN) {
-  size_t i;
+template <class T>
+void show_data(T *arr, size_t LEN)
+{
+    size_t i;
 
-  for (i = 0; i < LEN; i++)
-    std::cout << arr[i] << ", ";
-  std::cout << std::endl;
+    for (i = 0; i < LEN; i++) std::cout << arr[i] << ", ";
+    std::cout << std::endl;
 }
 
-template <class T, size_t N> void show_data(T (&arr)[N]) { show_data(arr, N); }
+template <class T, size_t N>
+void show_data(T (&arr)[N])
+{
+    show_data(arr, N);
+}
 
 /**
  * Optimized algorithm - takes half the time by utilizing
  * Mar
  **/
-template <class T> void shell_sort(T *arr, size_t LEN) {
-  const unsigned int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
-  const unsigned int gap_len = 8;
-  size_t i, j, g;
+template <class T>
+void shell_sort(T *arr, size_t LEN)
+{
+    const unsigned int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
+    const unsigned int gap_len = 8;
+    size_t i, j, g;
 
-  for (g = 0; g < gap_len; g++) {
-    unsigned int gap = gaps[g];
-    for (i = gap; i < LEN; i++) {
-      T tmp = arr[i];
+    for (g = 0; g < gap_len; g++)
+    {
+        unsigned int gap = gaps[g];
+        for (i = gap; i < LEN; i++)
+        {
+            T tmp = arr[i];
 
-      for (j = i; j >= gap && (arr[j - gap] - tmp) > 0; j -= gap)
-        arr[j] = arr[j - gap];
+            for (j = i; j >= gap && (arr[j - gap] - tmp) > 0; j -= gap)
+                arr[j] = arr[j - gap];
 
-      arr[j] = tmp;
+            arr[j] = tmp;
+        }
     }
-  }
 }
 
-template <class T, size_t N> void shell_sort(T (&arr)[N]) {
-  shell_sort(arr, N);
+template <class T, size_t N>
+void shell_sort(T (&arr)[N])
+{
+    shell_sort(arr, N);
 }
 
 /**
  * function to compare sorting using cstdlib's qsort
  **/
-int compare(const void *a, const void *b) {
-  int arg1 = *static_cast<const int *>(a);
-  int arg2 = *static_cast<const int *>(b);
+int compare(const void *a, const void *b)
+{
+    int arg1 = *static_cast<const int *>(a);
+    int arg2 = *static_cast<const int *>(b);
 
-  if (arg1 < arg2)
-    return -1;
-  if (arg1 > arg2)
-    return 1;
-  return 0;
+    if (arg1 < arg2)
+        return -1;
+    if (arg1 > arg2)
+        return 1;
+    return 0;
 
-  //  return (arg1 > arg2) - (arg1 < arg2); // possible shortcut
-  //  return arg1 - arg2; // erroneous shortcut (fails if INT_MIN is present)
+    //  return (arg1 > arg2) - (arg1 < arg2); // possible shortcut
+    //  return arg1 - arg2; // erroneous shortcut (fails if INT_MIN is present)
 }
 
-int main(int argc, char *argv[]) {
-  int i, NUM_DATA;
+int main(int argc, char *argv[])
+{
+    int i, NUM_DATA;
 
-  if (argc == 2)
-    NUM_DATA = atoi(argv[1]);
-  else
-    NUM_DATA = 200;
+    if (argc == 2)
+        NUM_DATA = atoi(argv[1]);
+    else
+        NUM_DATA = 200;
 
-  // int array = new int[NUM_DATA];
-  int *data = new int[NUM_DATA];
-  int *data2 = new int[NUM_DATA];
-  // int array2 = new int[NUM_DATA];
-  int range = 1800;
+    // int array = new int[NUM_DATA];
+    int *data = new int[NUM_DATA];
+    int *data2 = new int[NUM_DATA];
+    // int array2 = new int[NUM_DATA];
+    int range = 1800;
 
-  std::srand(time(NULL));
-  for (i = 0; i < NUM_DATA; i++)
-    data[i] = data2[i] = (std::rand() % range) - (range >> 1);
+    std::srand(time(NULL));
+    for (i = 0; i < NUM_DATA; i++)
+        data[i] = data2[i] = (std::rand() % range) - (range >> 1);
 
-  std::cout << "Unsorted original data: " << std::endl;
-  show_data(data, NUM_DATA);
-  std::clock_t start = std::clock();
-  shell_sort(data, NUM_DATA);
-  std::clock_t end = std::clock();
+    std::cout << "Unsorted original data: " << std::endl;
+    show_data(data, NUM_DATA);
+    std::clock_t start = std::clock();
+    shell_sort(data, NUM_DATA);
+    std::clock_t end = std::clock();
 
-  std::cout << std::endl
-            << "Data Sorted using custom implementation: " << std::endl;
-  show_data(data, NUM_DATA);
+    std::cout << std::endl
+              << "Data Sorted using custom implementation: " << std::endl;
+    show_data(data, NUM_DATA);
 
-  double elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
-  std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
+    double elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
+    std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
 
-  start = std::clock();
-  qsort(data2, NUM_DATA, sizeof(data2[0]), compare);
-  end = std::clock();
-  std::cout << "Data Sorted using cstdlib qsort: " << std::endl;
-  show_data(data2, NUM_DATA);
+    start = std::clock();
+    qsort(data2, NUM_DATA, sizeof(data2[0]), compare);
+    end = std::clock();
+    std::cout << "Data Sorted using cstdlib qsort: " << std::endl;
+    show_data(data2, NUM_DATA);
 
-  elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
-  std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
+    elapsed_time = (end - start) * 1.f / CLOCKS_PER_SEC;
+    std::cout << "Time spent sorting: " << elapsed_time << "s\n" << std::endl;
 
-  free(data);
-  free(data2);
-  return 0;
+    free(data);
+    free(data2);
+    return 0;
 }
diff --git a/sorting/slow_sort.cpp b/sorting/slow_sort.cpp
index b2627d12f..e4f175af6 100644
--- a/sorting/slow_sort.cpp
+++ b/sorting/slow_sort.cpp
@@ -10,14 +10,17 @@
 
 #include <iostream>
 
-void SlowSort(int a[], int i, int j) {
-    if (i >= j) return;
+void SlowSort(int a[], int i, int j)
+{
+    if (i >= j)
+        return;
     int m = i + (j - i) / 2;  // midpoint, implemented this way to avoid
                               // overflow
     int temp;
     SlowSort(a, i, m);
     SlowSort(a, m + 1, j);
-    if (a[j] < a[m]) {
+    if (a[j] < a[m])
+    {
         temp = a[j];  // swapping a[j] & a[m]
         a[j] = a[m];
         a[m] = temp;
@@ -27,7 +30,8 @@ void SlowSort(int a[], int i, int j) {
 
 // Sample Main function
 
-int main() {
+int main()
+{
     int size;
     std::cout << "\nEnter the number of elements : ";
 
@@ -37,7 +41,8 @@ int main() {
 
     std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i) {
+    for (int i = 0; i < size; ++i)
+    {
         std::cout << "\n";
         std::cin >> arr[i];
     }
@@ -46,7 +51,8 @@ int main() {
 
     std::cout << "Sorted array\n";
 
-    for (int i = 0; i < size; ++i) {
+    for (int i = 0; i < size; ++i)
+    {
         std::cout << arr[i] << " ";
     }
 
diff --git a/sorting/swap_sort.cpp b/sorting/swap_sort.cpp
index 2e59e2fb3..7d391d8a1 100644
--- a/sorting/swap_sort.cpp
+++ b/sorting/swap_sort.cpp
@@ -6,12 +6,14 @@
 
 // Function returns the minimum number of swaps
 // required to sort the array
-int minSwaps(int arr[], int n) {
+int minSwaps(int arr[], int n)
+{
     // Create an array of pairs where first
     // element is array element and second element
     // is position of first element
     std::pair<int, int> *arrPos = new std::pair<int, int>[n];
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         arrPos[i].first = arr[i];
         arrPos[i].second = i;
     }
@@ -29,16 +31,19 @@ int minSwaps(int arr[], int n) {
     int ans = 0;
 
     // Traverse array elements
-    for (int i = 0; i < n; i++) {
+    for (int i = 0; i < n; i++)
+    {
         // already swapped and corrected or
         // already present at correct pos
-        if (vis[i] || arrPos[i].second == i) continue;
+        if (vis[i] || arrPos[i].second == i)
+            continue;
 
         // find out the number of node in
         // this cycle and add in ans
         int cycle_size = 0;
         int j = i;
-        while (!vis[j]) {
+        while (!vis[j])
+        {
             vis[j] = 1;
 
             // move to next node
@@ -47,7 +52,8 @@ int minSwaps(int arr[], int n) {
         }
 
         // Update answer by adding current cycle.
-        if (cycle_size > 0) {
+        if (cycle_size > 0)
+        {
             ans += (cycle_size - 1);
         }
     }
@@ -59,7 +65,8 @@ int minSwaps(int arr[], int n) {
 }
 
 // program to test
-int main() {
+int main()
+{
     int arr[] = {6, 7, 8, 1, 2, 3, 9, 12};
     int n = (sizeof(arr) / sizeof(int));
     std::cout << minSwaps(arr, n);
diff --git a/sorting/tim_sort.cpp b/sorting/tim_sort.cpp
index 94f5aa230..9645a60b1 100644
--- a/sorting/tim_sort.cpp
+++ b/sorting/tim_sort.cpp
@@ -6,11 +6,14 @@ const int RUN = 32;
 
 // this function sorts array from left index to to right index which is of size
 // atmost RUN
-void insertionSort(int arr[], int left, int right) {
-    for (int i = left + 1; i <= right; i++) {
+void insertionSort(int arr[], int left, int right)
+{
+    for (int i = left + 1; i <= right; i++)
+    {
         int temp = arr[i];
         int j = i - 1;
-        while (arr[j] > temp && j >= left) {
+        while (arr[j] > temp && j >= left)
+        {
             arr[j + 1] = arr[j];
             j--;
         }
@@ -19,7 +22,8 @@ void insertionSort(int arr[], int left, int right) {
 }
 
 // merge function merges the sorted runs
-void merge(int arr[], int l, int m, int r) {
+void merge(int arr[], int l, int m, int r)
+{
     // original array is broken in two parts, left and right array
     int len1 = m - l + 1, len2 = r - m;
     int *left = new int[len1], *right = new int[len2];
@@ -31,11 +35,15 @@ void merge(int arr[], int l, int m, int r) {
     int k = l;
 
     // after comparing, we merge those two array in larger sub array
-    while (i < len1 && j < len2) {
-        if (left[i] <= right[j]) {
+    while (i < len1 && j < len2)
+    {
+        if (left[i] <= right[j])
+        {
             arr[k] = left[i];
             i++;
-        } else {
+        }
+        else
+        {
             arr[k] = right[j];
             j++;
         }
@@ -43,14 +51,16 @@ void merge(int arr[], int l, int m, int r) {
     }
 
     // copy remaining elements of left, if any
-    while (i < len1) {
+    while (i < len1)
+    {
         arr[k] = left[i];
         k++;
         i++;
     }
 
     // copy remaining element of right, if any
-    while (j < len2) {
+    while (j < len2)
+    {
         arr[k] = right[j];
         k++;
         j++;
@@ -60,18 +70,21 @@ void merge(int arr[], int l, int m, int r) {
 }
 
 // iterative Timsort function to sort the array[0...n-1] (similar to merge sort)
-void timSort(int arr[], int n) {
+void timSort(int arr[], int n)
+{
     // Sort individual subarrays of size RUN
     for (int i = 0; i < n; i += RUN)
         insertionSort(arr, i, std::min((i + 31), (n - 1)));
 
     // start merging from size RUN (or 32). It will merge to form size 64, then
     // 128, 256 and so on ....
-    for (int size = RUN; size < n; size = 2 * size) {
+    for (int size = RUN; size < n; size = 2 * size)
+    {
         // pick starting point of left sub array. We are going to merge
         // arr[left..left+size-1] and arr[left+size, left+2*size-1] After every
         // merge, we increase left by 2*size
-        for (int left = 0; left < n; left += 2 * size) {
+        for (int left = 0; left < n; left += 2 * size)
+        {
             // find ending point of left sub array
             // mid+1 is starting point of right sub array
             int mid = left + size - 1;
@@ -84,13 +97,15 @@ void timSort(int arr[], int n) {
 }
 
 // utility function to print the Array
-void printArray(int arr[], int n) {
+void printArray(int arr[], int n)
+{
     for (int i = 0; i < n; i++) printf("%d  ", arr[i]);
     std::cout << std::endl;
 }
 
 // Driver program to test above function
-int main() {
+int main()
+{
     int arr[] = {5, 21, 7, 23, 19};
     int n = sizeof(arr) / sizeof(arr[0]);
     printf("Given Array is\n");
diff --git a/strings/brute_force_string_searching.cpp b/strings/brute_force_string_searching.cpp
index 9a2b5327a..5f6116e1b 100644
--- a/strings/brute_force_string_searching.cpp
+++ b/strings/brute_force_string_searching.cpp
@@ -17,14 +17,18 @@
  * @return         Index where the pattern starts in the text
  * @return         -1 if the pattern was not found.
  */
-int brute_force(const std::string &text, const std::string &pattern) {
+int brute_force(const std::string &text, const std::string &pattern)
+{
     size_t pat_l = pattern.length();
     size_t txt_l = text.length();
     int index = -1;
-    if (pat_l <= txt_l) {
-        for (size_t i = 0; i < txt_l - pat_l + 1; i++) {
+    if (pat_l <= txt_l)
+    {
+        for (size_t i = 0; i < txt_l - pat_l + 1; i++)
+        {
             std::string s = text.substr(i, pat_l);
-            if (s == pattern) {
+            if (s == pattern)
+            {
                 index = i;
                 break;
             }
@@ -40,8 +44,10 @@ const std::vector<std::vector<std::string>> test_set = {
     {"bba", "bb", "0"}, {"bbca", "c", "2"}, {"ab", "b", "1"}};
 
 /** Main function */
-int main() {
-    for (size_t i = 0; i < test_set.size(); i++) {
+int main()
+{
+    for (size_t i = 0; i < test_set.size(); i++)
+    {
         int output = brute_force(test_set[i][0], test_set[i][1]);
 
         if (std::to_string(output) == test_set[i][2])
diff --git a/strings/knuth_morris_pratt.cpp b/strings/knuth_morris_pratt.cpp
index b83cab966..29e6ef834 100644
--- a/strings/knuth_morris_pratt.cpp
+++ b/strings/knuth_morris_pratt.cpp
@@ -26,14 +26,17 @@
  * \param[in] pattern text for which to create the partial match table
  * \returns the partial match table as a vector array
  */
-std::vector<int> getFailureArray(const std::string &pattern) {
+std::vector<int> getFailureArray(const std::string &pattern)
+{
     int pattern_length = pattern.size();
     std::vector<int> failure(pattern_length + 1);
     failure[0] = -1;
     int j = -1;
 
-    for (int i = 0; i < pattern_length; i++) {
-        while (j != -1 && pattern[j] != pattern[i]) {
+    for (int i = 0; i < pattern_length; i++)
+    {
+        while (j != -1 && pattern[j] != pattern[i])
+        {
             j = failure[j];
         }
         j++;
@@ -49,13 +52,16 @@ std::vector<int> getFailureArray(const std::string &pattern) {
  * \returns `true` if pattern was found
  * \returns `false` if pattern was not found
  */
-bool kmp(const std::string &pattern, const std::string &text) {
+bool kmp(const std::string &pattern, const std::string &text)
+{
     int text_length = text.size(), pattern_length = pattern.size();
     std::vector<int> failure = getFailureArray(pattern);
 
     int k = 0;
-    for (int j = 0; j < text_length; j++) {
-        while (k != -1 && pattern[k] != text[j]) {
+    for (int j = 0; j < text_length; j++)
+    {
+        while (k != -1 && pattern[k] != text[j])
+        {
             k = failure[k];
         }
         k++;
@@ -66,21 +72,28 @@ bool kmp(const std::string &pattern, const std::string &text) {
 }
 
 /** Main function */
-int main() {
+int main()
+{
     std::string text = "alskfjaldsabc1abc1abc12k23adsfabcabc";
     std::string pattern = "abc1abc12l";
 
-    if (kmp(pattern, text) == true) {
+    if (kmp(pattern, text) == true)
+    {
         std::cout << "Found" << std::endl;
-    } else {
+    }
+    else
+    {
         std::cout << "Not Found" << std::endl;
     }
 
     text = "abcabc";
     pattern = "bca";
-    if (kmp(pattern, text) == true) {
+    if (kmp(pattern, text) == true)
+    {
         std::cout << "Found" << std::endl;
-    } else {
+    }
+    else
+    {
         std::cout << "Not Found" << std::endl;
     }
 
diff --git a/strings/rabin_karp.cpp b/strings/rabin_karp.cpp
index 018ff5632..5baaaf615 100644
--- a/strings/rabin_karp.cpp
+++ b/strings/rabin_karp.cpp
@@ -21,9 +21,11 @@
  * \param[in] n length of substring to hash
  * \returns hash integer
  */
-int64_t create_hash(const std::string& s, int n) {
+int64_t create_hash(const std::string& s, int n)
+{
     int64_t result = 0;
-    for (int i = 0; i < n; ++i) {
+    for (int i = 0; i < n; ++i)
+    {
         result += (int64_t)(s[i] * (int64_t)pow(PRIME, i));
     }
     return result;
@@ -39,7 +41,8 @@ int64_t create_hash(const std::string& s, int n) {
  * \returns new hash integer
  */
 int64_t recalculate_hash(const std::string& s, int old_index, int new_index,
-                         int64_t old_hash, int patLength) {
+                         int64_t old_hash, int patLength)
+{
     int64_t new_hash = old_hash - s[old_index];
     new_hash /= PRIME;
     new_hash += (int64_t)(s[new_index] * (int64_t)pow(PRIME, patLength - 1));
@@ -57,12 +60,16 @@ int64_t recalculate_hash(const std::string& s, int old_index, int new_index,
  * @note can this be replaced by std::string::compare?
  */
 bool check_if_equal(const std::string& str1, const std::string& str2,
-                    int start1, int end1, int start2, int end2) {
-    if (end1 - start1 != end2 - start2) {
+                    int start1, int end1, int start2, int end2)
+{
+    if (end1 - start1 != end2 - start2)
+    {
         return false;
     }
-    while (start1 <= end1 && start2 <= end2) {
-        if (str1[start1] != str2[start2]) {
+    while (start1 <= end1 && start2 <= end2)
+    {
+        if (str1[start1] != str2[start2])
+        {
             return false;
         }
         start1++;
@@ -79,16 +86,19 @@ bool check_if_equal(const std::string& str1, const std::string& str2,
  *  @return -1 if pattern not found
  */
 
-int rabin_karp(const std::string& str, const std::string& pat) {
+int rabin_karp(const std::string& str, const std::string& pat)
+{
     int64_t pat_hash = create_hash(pat, pat.size());
     int64_t str_hash = create_hash(str, pat.size());
-    for (int i = 0; i <= str.size() - pat.size(); ++i) {
+    for (int i = 0; i <= str.size() - pat.size(); ++i)
+    {
         if (pat_hash == str_hash &&
-            check_if_equal(str, pat, i, i + pat.size() - 1, 0,
-                           pat.size() - 1)) {
+            check_if_equal(str, pat, i, i + pat.size() - 1, 0, pat.size() - 1))
+        {
             return i;
         }
-        if (i < str.size() - pat.size()) {
+        if (i < str.size() - pat.size())
+        {
             str_hash =
                 recalculate_hash(str, i, i + pat.size(), str_hash, pat.size());
         }
@@ -97,7 +107,8 @@ int rabin_karp(const std::string& str, const std::string& pat) {
 }
 
 /** Main function */
-int main(void) {
+int main(void)
+{
     assert(rabin_karp("helloWorld", "world") == -1);
     assert(rabin_karp("helloWorld", "World") == 5);
     assert(rabin_karp("this_is_c++", "c++") == 8);

From 7e634c2cb34442e73892a6764dc601f25008f7c4 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 19:30:10 -0400
Subject: [PATCH 271/290] remove allman break before braces

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index a8d61e423..94cd125bb 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -50,7 +50,7 @@ jobs:
           git commit -am "formatting source-code for $GITHUB_SHA" ||  true
         env:
           line1: "{ BasedOnStyle: Google, UseTab: Never,"
-          line2: "IndentWidth: 4, TabWidth: 4, BreakBeforeBraces: Allman,"
+          line2: "IndentWidth: 4, TabWidth: 4"
           line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
           line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
       - name: Git Push

From 5c40942257209da5889985da12be758b10269317 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 29 May 2020 23:30:37 +0000
Subject: [PATCH 272/290] updating DIRECTORY.md

---
 DIRECTORY.md | 96 ++++++++++++++++++++++++++--------------------------
 1 file changed, 48 insertions(+), 48 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index d90326050..334538685 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -18,10 +18,10 @@
   * [Successive Approximation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/computer_oriented_statistical_methods/successive_approximation.cpp)
 
 ## Data Structure
-  * [Avltree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/AVLtree.cpp)
-  * [Binary Search Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Binary%20Search%20Tree.cpp)
-  * [Binaryheap](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Binaryheap.cpp)
-  * [Circular Queue Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/circular_Queue_using_Linked_List.cpp)
+  * [Avltree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/avltree.cpp)
+  * [Binary Search Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/binary_search_tree.cpp)
+  * [Binaryheap](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/binaryheap.cpp)
+  * [Circular Queue Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/circular_queue_using_linked_list.cpp)
   * Cll
     * [Cll](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/cll/cll.cpp)
     * [Cll](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/cll/cll.h)
@@ -29,73 +29,73 @@
   * [Disjoint Set](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/disjoint_set.cpp)
   * [Doubly Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/doubly_linked_list.cpp)
   * [Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/linked_list.cpp)
-  * [Linkedlist Implentation Usingarray](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/linkedList_implentation_usingArray.cpp)
-  * [List Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/List%20Array.cpp)
-  * [Morrisinorder](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/MorrisInorder.cpp)
-  * [Queue Using Array2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Queue%20Using%20Array2.cpp)
-  * [Queue Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Queue%20Using%20Linked%20List.cpp)
+  * [Linkedlist Implentation Usingarray](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/linkedlist_implentation_usingarray.cpp)
+  * [List Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/list_array.cpp)
+  * [Morrisinorder](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/morrisinorder.cpp)
   * Queue
     * [Queue](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue/queue.cpp)
     * [Queue](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue/queue.h)
     * [Test Queue](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue/test_queue.cpp)
   * [Queue Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue_using_array.cpp)
+  * [Queue Using Array2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue_using_array2.cpp)
+  * [Queue Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue_using_linked_list.cpp)
   * [Queue Using Linkedlist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/queue_using_linkedlist.cpp)
-  * [Stack Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Stack%20Using%20Array.cpp)
-  * [Stack Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Stack%20Using%20Linked%20List.cpp)
+  * [Stack Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/stack_using_array.cpp)
+  * [Stack Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/stack_using_linked_list.cpp)
   * Stk
     * [Main](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/stk/main.cpp)
     * [Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/stk/stack.cpp)
     * [Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/stk/stack.h)
     * [Test Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/stk/test_stack.cpp)
-  * [Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/Tree.cpp)
+  * [Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/tree.cpp)
   * [Trie Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structure/trie_tree.cpp)
 
 ## Dynamic Programming
-  * [0-1 Knapsack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/0-1%20Knapsack.cpp)
+  * [0 1 Knapsack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/0_1_knapsack.cpp)
   * [Armstrong Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/armstrong_number.cpp)
-  * [Bellman-Ford](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Bellman-Ford.cpp)
-  * [Catalan-Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Catalan-Numbers.cpp)
-  * [Coin-Change](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Coin-Change.cpp)
-  * [Cut Rod](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Cut%20Rod.cpp)
-  * [Edit Distance](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Edit%20Distance.cpp)
-  * [Egg-Dropping-Puzzle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Egg-Dropping-Puzzle.cpp)
-  * [Fibonacci Bottom Up](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Fibonacci_Bottom_Up.cpp)
-  * [Fibonacci Top Down](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Fibonacci_Top_Down.cpp)
-  * [Floyd-Warshall](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Floyd-Warshall.cpp)
+  * [Bellman Ford](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/bellman_ford.cpp)
+  * [Catalan Numbers](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/catalan_numbers.cpp)
+  * [Coin Change](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/coin_change.cpp)
+  * [Cut Rod](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/cut_rod.cpp)
+  * [Edit Distance](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/edit_distance.cpp)
+  * [Egg Dropping Puzzle](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/egg_dropping_puzzle.cpp)
+  * [Fibonacci Bottom Up](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/fibonacci_bottom_up.cpp)
+  * [Fibonacci Top Down](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/fibonacci_top_down.cpp)
+  * [Floyd Warshall](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/floyd_warshall.cpp)
   * [Kadane](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/kadane.cpp)
-  * [Longest Common Subsequence](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Longest%20Common%20Subsequence.cpp)
-  * [Longest Increasing Subsequence (Nlogn)](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Longest%20Increasing%20Subsequence%20(nlogn).cpp)
-  * [Longest Increasing Subsequence](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Longest%20Increasing%20Subsequence.cpp)
   * [Longest Common String](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/longest_common_string.cpp)
-  * [Matrix-Chain-Multiplication](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/Matrix-Chain-Multiplication.cpp)
+  * [Longest Common Subsequence](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/longest_common_subsequence.cpp)
+  * [Longest Increasing Subsequence](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/longest_increasing_subsequence.cpp)
+  * [Longest Increasing Subsequence (Nlogn)](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp)
+  * [Matrix Chain Multiplication](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/matrix_chain_multiplication.cpp)
   * [Searching Of Element In Dynamic Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/searching_of_element_in_dynamic_array.cpp)
   * [Tree Height](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/tree_height.cpp)
 
 ## Graph
-  * [Bfs](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/BFS.cpp)
+  * [Bfs](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/bfs.cpp)
   * [Bridge Finding With Tarjan Algorithm](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/bridge_finding_with_tarjan_algorithm.cpp)
   * [Connected Components](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/connected_components.cpp)
   * [Connected Components With Dsu](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/connected_components_with_dsu.cpp)
-  * [Dfs](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/DFS.cpp)
+  * [Dfs](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/dfs.cpp)
   * [Dfs With Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/DFS_with_stack.cc)
-  * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/Dijkstra.cpp)
+  * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/dijkstra.cpp)
   * [Kosaraju](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/kosaraju.cpp)
-  * [Kruskal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/Kruskal.cpp)
+  * [Kruskal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/kruskal.cpp)
   * [Lca](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/lca.cpp)
   * [Max Flow With Ford Fulkerson And Edmond Karp Algo](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp)
   * [Prim](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/prim.cpp)
-  * [Topological-Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/Topological-Sort.cpp)
+  * [Topological Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/topological_sort.cpp)
   * [Topological Sort By Kahns Algo](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/topological_sort_by_kahns_algo.cpp)
 
 ## Greedy Algorithms
-  * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/Dijkstra.cpp)
+  * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/dijkstra.cpp)
   * [Huffman](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/huffman.cpp)
-  * [Knapsack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/Knapsack.cpp)
-  * [Kruskals Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/Kruskals%20Minimum%20Spanning%20Tree.cpp)
-  * [Prims Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/Prims%20Minimum%20Spanning%20Tree.cpp)
+  * [Knapsack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/knapsack.cpp)
+  * [Kruskals Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/kruskals_minimum_spanning_tree.cpp)
+  * [Prims Minimum Spanning Tree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/prims_minimum_spanning_tree.cpp)
 
 ## Hashing
-  * [Chaining](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/hashing/Chaining.cpp)
+  * [Chaining](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/hashing/chaining.cpp)
   * [Double Hash Hash Table](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/hashing/double_hash_hash_table.cpp)
   * [Linear Probing Hash Table](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/hashing/linear_probing_hash_table.cpp)
   * [Quadratic Probing Hash Table](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/hashing/quadratic_probing_hash_table.cpp)
@@ -126,15 +126,15 @@
   * [String Fibonacci](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/string_fibonacci.cpp)
 
 ## Operations On Datastructures
-  * [Array Left Rotation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Array%20Left%20Rotation.cpp)
-  * [Array Right Rotation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Array%20Right%20Rotation.cpp)
-  * [Circular Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Circular%20Linked%20List.cpp)
-  * [Circular Queue Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Circular%20Queue%20Using%20Array.cpp)
+  * [Array Left Rotation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/array_left_rotation.cpp)
+  * [Array Right Rotation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/array_right_rotation.cpp)
+  * [Circular Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/circular_linked_list.cpp)
+  * [Circular Queue Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/circular_queue_using_array.cpp)
   * [Get Size Of Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/get_size_of_linked_list.cpp)
-  * [Intersection Of 2 Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Intersection_of_2_arrays.cpp)
-  * [Reverse A Linked List Using Recusion](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Reverse%20a%20Linked%20List%20using%20Recusion.cpp)
-  * [Selectionsortlinkedlist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/selectionSortLinkedList.cpp)
-  * [Union Of 2 Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/Union_of_2_arrays.cpp)
+  * [Intersection Of 2 Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/intersection_of_2_arrays.cpp)
+  * [Reverse A Linked List Using Recusion](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp)
+  * [Selectionsortlinkedlist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/selectionsortlinkedlist.cpp)
+  * [Union Of 2 Arrays](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/operations_on_datastructures/union_of_2_arrays.cpp)
 
 ## Others
   * [Buzz Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/others/buzz_number.cpp)
@@ -163,9 +163,9 @@
 
 ## Range Queries
   * [Bit](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/range_queries/bit.cpp)
-  * [Fenwicktree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/range_queries/FenwickTree.cpp)
-  * [Mo](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/range_queries/MO.cpp)
-  * [Segtree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/range_queries/segTree.cpp)
+  * [Fenwicktree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/range_queries/fenwicktree.cpp)
+  * [Mo](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/range_queries/mo.cpp)
+  * [Segtree](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/range_queries/segtree.cpp)
 
 ## Search
   * [Binary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/binary_search.cpp)
@@ -186,7 +186,7 @@
   * [Bucket Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bucket_sort.cpp)
   * [Cocktail Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/cocktail_selection_sort.cpp)
   * [Comb Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/comb_sort.cpp)
-  * [Counting Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/Counting_Sort.cpp)
+  * [Counting Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/counting_sort.cpp)
   * [Counting Sort String](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/counting_sort_string.cpp)
   * [Heap Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/heap_sort.cpp)
   * [Insertion Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/insertion_sort.cpp)

From daca1b5715dc069e8f956b6256eeb0fc25713bca Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 19:31:48 -0400
Subject: [PATCH 273/290] added missing comma lost in previous commit

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 94cd125bb..191e121cd 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -50,7 +50,7 @@ jobs:
           git commit -am "formatting source-code for $GITHUB_SHA" ||  true
         env:
           line1: "{ BasedOnStyle: Google, UseTab: Never,"
-          line2: "IndentWidth: 4, TabWidth: 4"
+          line2: "IndentWidth: 4, TabWidth: 4, "
           line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
           line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
       - name: Git Push

From e9d29caf6b30ef54d2599e397eb0b309c2c70cf2 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 21:23:17 -0400
Subject: [PATCH 274/290] orchestrate all workflows

---
 .github/workflows/ccpp.yml                   | 23 -----
 .github/workflows/clang-format.yml           | 96 +++++++++++++++++++-
 .github/workflows/cpplint.yml                | 13 ---
 .github/workflows/cpplint_modified_files.yml | 66 --------------
 .github/workflows/update_directory_md.yml    | 68 --------------
 5 files changed, 94 insertions(+), 172 deletions(-)
 delete mode 100644 .github/workflows/ccpp.yml
 delete mode 100644 .github/workflows/cpplint.yml
 delete mode 100644 .github/workflows/cpplint_modified_files.yml
 delete mode 100644 .github/workflows/update_directory_md.yml

diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
deleted file mode 100644
index 34085cdec..000000000
--- a/.github/workflows/ccpp.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: C/C++ CI
-
-on: [push]
-#   push:
-#     branches: [ master ]
-#   pull_request:
-#     branches: [ master ]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macOS-latest]
-
-    steps:
-      - uses: actions/checkout@master
-        with:
-          submodules: true
-      - name: configure
-        run: cmake -B ./build -S .
-      - name: build
-        run: cmake --build build
diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 191e121cd..092564fc4 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -1,4 +1,4 @@
-name: Code Formatting
+name: Long CI Workflow
 
 on: [push]
 #   push:
@@ -7,7 +7,8 @@ on: [push]
 #     branches: [ master ]
 
 jobs:
-  build:
+  code_format:
+    name: Code Formatter
     runs-on: ubuntu-latest
     steps:
       - name: requirements
@@ -55,3 +56,94 @@ jobs:
           line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
       - name: Git Push
         run: git pull && git push
+  
+  update_directory_md:
+    name: Update Directory.md
+    needs: code_format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v1
+      - name: update_directory_md
+        shell: python
+        run: |
+            import os
+            from typing import Iterator
+
+            URL_BASE = "https://github.com/TheAlgorithms/C-Plus-Plus/blob/master"
+            g_output = []
+
+
+            def good_filepaths(top_dir: str = ".") -> Iterator[str]:
+                cpp_exts = tuple(".c .c++ .cc .cpp .cu .cuh .cxx .h .h++ .hh .hpp .hxx".split())
+                for dirpath, dirnames, filenames in os.walk(top_dir):
+                    dirnames[:] = [d for d in dirnames if d[0] not in "._"]
+                    for filename in filenames:
+                        if os.path.splitext(filename)[1].lower() in cpp_exts:
+                            yield os.path.join(dirpath, filename).lstrip("./")
+
+
+            def md_prefix(i):
+                return f"{i * '  '}*" if i else "\n##"
+
+
+            def print_path(old_path: str, new_path: str) -> str:
+                global g_output
+                old_parts = old_path.split(os.sep)
+                for i, new_part in enumerate(new_path.split(os.sep)):
+                    if i + 1 > len(old_parts) or old_parts[i] != new_part:
+                        if new_part:
+                            g_output.append(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
+                return new_path
+
+
+            def build_directory_md(top_dir: str = ".") -> str:
+                global g_output
+                old_path = ""
+                for filepath in sorted(good_filepaths(), key=str.lower):
+                    filepath, filename = os.path.split(filepath)
+                    if filepath != old_path:
+                        old_path = print_path(old_path, filepath)
+                    indent = (filepath.count(os.sep) + 1) if filepath else 0
+                    url = "/".join((URL_BASE, filepath, filename)).replace(" ", "%20")
+                    filename = os.path.splitext(filename.replace("_", " ").title())[0]
+                    g_output.append(f"{md_prefix(indent)} [{filename}]({url})")
+                return "\n".join(g_output)
+
+
+            with open("DIRECTORY.md", "w") as out_file:
+                out_file.write(build_directory_md(".") + "\n")
+      - name: Update DIRECTORY.md
+        run: |
+          cat DIRECTORY.md
+          git config --global user.name github-actions
+          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+          git add DIRECTORY.md
+          git commit -am "updating DIRECTORY.md" ||  true
+          git push --force origin HEAD:$GITHUB_REF || true
+
+  cpplint:
+    name: CPPLINT
+    needs: code_format
+    runs-on: ubuntu-latest
+      steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-python@v1
+      - run: pip install cpplint
+      - run: cpplint --filter=-legal --recursive .
+
+  build:
+    runs-on: ${{ matrix.os }}
+    needs: [cpplint, update_directory_md]
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+    steps:
+      - uses: actions/checkout@master
+        with:
+          submodules: true
+      - name: configure
+        run: cmake -B ./build -S .
+      - name: build
+        run: cmake --build build
diff --git a/.github/workflows/cpplint.yml b/.github/workflows/cpplint.yml
deleted file mode 100644
index a6999e1f2..000000000
--- a/.github/workflows/cpplint.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-name: cpplint
-on: [push, pull_request]
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-python@v1
-    - run: pip install cpplint
-    # - run: cpplint --filter=  # print out all cpplint rules
-    - run: cpplint --recursive . || true  # all issues to be fixed
-    # TODO: Remove each filter one at a time and fix those failures
-    - run: cpplint --filter=-build,-legal,-readability,-runtime,-whitespace --recursive .
diff --git a/.github/workflows/cpplint_modified_files.yml b/.github/workflows/cpplint_modified_files.yml
deleted file mode 100644
index a5aa6a652..000000000
--- a/.github/workflows/cpplint_modified_files.yml
+++ /dev/null
@@ -1,66 +0,0 @@
-# GitHub Action that enables a repo to achieve gradual compliance with cpplint by
-#     linting only those files that have been added or modified (vs. origin/master).
-# 1. runs cpplint only on those files that have been modified vs. origin/master.
-# 2. compiles with g++ only those files that have been modified vs. origin/master.
-# 3. other optional filepath verifications may be commented out at the end of this file.
-# From: https://github.com/cpplint/GitHub-Action-for-cpplint
-
-name: cpplint_modified_files
-on: [push, pull_request]
-jobs:
-  cpplint_modified_files:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v1 # v2 is broken for git diff
-      - uses: actions/setup-python@v1
-      - run: python -m pip install cpplint
-      - run: git remote -v
-      - run: git branch
-      - run: git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
-      - run: git diff --diff-filter=dr --name-only origin/master > git_diff.txt
-      - name: cpplint_modified_files
-        shell: python
-        run: |
-          import os
-          import subprocess
-          import sys
-
-          print("Python {}.{}.{}".format(*sys.version_info))  # Python 3.8
-          with open("git_diff.txt") as in_file:
-            modified_files = sorted(in_file.read().splitlines())
-          print("{} files were modified.".format(len(modified_files)))
-
-          cpp_exts = tuple(".c .c++ .cc .cpp .cu .cuh .cxx .h .h++ .hh .hpp .hxx".split())
-          cpp_files = [file for file in modified_files if file.lower().endswith(cpp_exts)]
-          print(f"{len(cpp_files)} C++ files were modified.")
-          if not cpp_files:
-            sys.exit(0)
-
-          print("cpplint:")
-          for cpp_file in cpp_files:
-            subprocess.run(["cpplint", "--filter=-legal/copyright", cpp_file], check=True, text=True)
-
-          print("g++:")
-          # compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split())
-          # compile_files = [file for file in cpp_files if file.lower().endswith(compile_exts)]
-          for cpp_file in cpp_files:
-            subprocess.run(["g++", cpp_file], check=True, text=True)
-
-          upper_files = [file for file in cpp_files if file != file.lower()]
-          if upper_files:
-            print(f"{len(upper_files)} files contain uppercase characters:")
-            print("\n".join(upper_files) + "\n")
-
-          space_files = [file for file in cpp_files if " " in file or "-" in file]
-          if space_files:
-            print(f"{len(space_files)} files contain space or dash characters:")
-            print("\n".join(space_files) + "\n")
-
-          nodir_files = [file for file in cpp_files if file.count(os.sep) != 1]
-          if nodir_files:
-            print(f"{len(nodir_files)} files are not in one and only one directory:")
-            print("\n".join(nodir_files) + "\n")
-
-          bad_files = len(upper_files + space_files + nodir_files)
-          if bad_files:
-            sys.exit(bad_files)
diff --git a/.github/workflows/update_directory_md.yml b/.github/workflows/update_directory_md.yml
deleted file mode 100644
index 1d63374b0..000000000
--- a/.github/workflows/update_directory_md.yml
+++ /dev/null
@@ -1,68 +0,0 @@
-# This GitHub Action updates the DIRECTORY.md file (if needed) when doing a git push
-name: update_directory_md
-on: [push]
-jobs:
-  update_directory_md:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v1
-      - name: update_directory_md
-        shell: python
-        run: |
-            import os
-            from typing import Iterator
-
-            URL_BASE = "https://github.com/TheAlgorithms/C-Plus-Plus/blob/master"
-            g_output = []
-
-
-            def good_filepaths(top_dir: str = ".") -> Iterator[str]:
-                cpp_exts = tuple(".c .c++ .cc .cpp .cu .cuh .cxx .h .h++ .hh .hpp .hxx".split())
-                for dirpath, dirnames, filenames in os.walk(top_dir):
-                    dirnames[:] = [d for d in dirnames if d[0] not in "._"]
-                    for filename in filenames:
-                        if os.path.splitext(filename)[1].lower() in cpp_exts:
-                            yield os.path.join(dirpath, filename).lstrip("./")
-
-
-            def md_prefix(i):
-                return f"{i * '  '}*" if i else "\n##"
-
-
-            def print_path(old_path: str, new_path: str) -> str:
-                global g_output
-                old_parts = old_path.split(os.sep)
-                for i, new_part in enumerate(new_path.split(os.sep)):
-                    if i + 1 > len(old_parts) or old_parts[i] != new_part:
-                        if new_part:
-                            g_output.append(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
-                return new_path
-
-
-            def build_directory_md(top_dir: str = ".") -> str:
-                global g_output
-                old_path = ""
-                for filepath in sorted(good_filepaths(), key=str.lower):
-                    filepath, filename = os.path.split(filepath)
-                    if filepath != old_path:
-                        old_path = print_path(old_path, filepath)
-                    indent = (filepath.count(os.sep) + 1) if filepath else 0
-                    url = "/".join((URL_BASE, filepath, filename)).replace(" ", "%20")
-                    filename = os.path.splitext(filename.replace("_", " ").title())[0]
-                    g_output.append(f"{md_prefix(indent)} [{filename}]({url})")
-                return "\n".join(g_output)
-
-
-            with open("DIRECTORY.md", "w") as out_file:
-                out_file.write(build_directory_md(".") + "\n")
-
-      - name: Update DIRECTORY.md
-        run: |
-          cat DIRECTORY.md
-          git config --global user.name github-actions
-          git config --global user.email '${GITHUB_ACTOR}@users.noreply.github.com'
-          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
-          git add DIRECTORY.md
-          git commit -am "updating DIRECTORY.md" ||  true
-          git push --force origin HEAD:$GITHUB_REF || true

From 3496cf3fa19276cd2ae89a92d11944660c717bda Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 21:25:19 -0400
Subject: [PATCH 275/290] fix yml indentation

---
 .github/workflows/clang-format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 092564fc4..57961b614 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -127,7 +127,7 @@ jobs:
     name: CPPLINT
     needs: code_format
     runs-on: ubuntu-latest
-      steps:
+    steps:
       - uses: actions/checkout@v1
       - uses: actions/setup-python@v1
       - run: pip install cpplint

From bc615f5bb9e1ba987ff87982664b690fb11aae86 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 21:38:46 -0400
Subject: [PATCH 276/290] force push format changes, add title to DIRECTORY.md

---
 .github/workflows/clang-format.yml | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 57961b614..ecccb1149 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -55,7 +55,7 @@ jobs:
           line3: "AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: false,"
           line4: "ColumnLimit: 80, AccessModifierOffset: -3 }"
       - name: Git Push
-        run: git pull && git push
+        run: git push --force origin HEAD:$GITHUB_REF || true
   
   update_directory_md:
     name: Update Directory.md
@@ -64,7 +64,7 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-python@v1
-      - name: update_directory_md
+      - name: Update DIRECTORY.md
         shell: python
         run: |
             import os
@@ -73,7 +73,6 @@ jobs:
             URL_BASE = "https://github.com/TheAlgorithms/C-Plus-Plus/blob/master"
             g_output = []
 
-
             def good_filepaths(top_dir: str = ".") -> Iterator[str]:
                 cpp_exts = tuple(".c .c++ .cc .cpp .cu .cuh .cxx .h .h++ .hh .hpp .hxx".split())
                 for dirpath, dirnames, filenames in os.walk(top_dir):
@@ -82,11 +81,9 @@ jobs:
                         if os.path.splitext(filename)[1].lower() in cpp_exts:
                             yield os.path.join(dirpath, filename).lstrip("./")
 
-
             def md_prefix(i):
                 return f"{i * '  '}*" if i else "\n##"
 
-
             def print_path(old_path: str, new_path: str) -> str:
                 global g_output
                 old_parts = old_path.split(os.sep)
@@ -96,7 +93,6 @@ jobs:
                             g_output.append(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
                 return new_path
 
-
             def build_directory_md(top_dir: str = ".") -> str:
                 global g_output
                 old_path = ""
@@ -108,8 +104,7 @@ jobs:
                     url = "/".join((URL_BASE, filepath, filename)).replace(" ", "%20")
                     filename = os.path.splitext(filename.replace("_", " ").title())[0]
                     g_output.append(f"{md_prefix(indent)} [{filename}]({url})")
-                return "\n".join(g_output)
-
+                return "# List of all files\n" + "\n".join(g_output)
 
             with open("DIRECTORY.md", "w") as out_file:
                 out_file.write(build_directory_md(".") + "\n")
@@ -134,6 +129,7 @@ jobs:
       - run: cpplint --filter=-legal --recursive .
 
   build:
+    name: Compile checks
     runs-on: ${{ matrix.os }}
     needs: [cpplint, update_directory_md]
     strategy:

From 40af5a53a934a63bc5360f7f853572f0db1047cb Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 21:42:32 -0400
Subject: [PATCH 277/290] pull before proceeding

---
 .github/workflows/clang-format.yml | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index ecccb1149..15a6ae647 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -64,6 +64,8 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-python@v1
+      - name: pull latest commit
+        run: git pull
       - name: Update DIRECTORY.md
         shell: python
         run: |
@@ -125,7 +127,9 @@ jobs:
     steps:
       - uses: actions/checkout@v1
       - uses: actions/setup-python@v1
-      - run: pip install cpplint
+      - run: |
+        pip install cpplint
+        git pull
       - run: cpplint --filter=-legal --recursive .
 
   build:
@@ -139,6 +143,8 @@ jobs:
       - uses: actions/checkout@master
         with:
           submodules: true
+      - name: git pull
+        run: git pull
       - name: configure
         run: cmake -B ./build -S .
       - name: build

From 388d06c8eecff6685b08bebbfc33020782495962 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 21:46:28 -0400
Subject: [PATCH 278/290] reorganize pull commands

---
 .github/workflows/clang-format.yml | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 15a6ae647..0cfa72e59 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -127,9 +127,8 @@ jobs:
     steps:
       - uses: actions/checkout@v1
       - uses: actions/setup-python@v1
-      - run: |
-        pip install cpplint
-        git pull
+      - run: pip install cpplint
+      - run: git pull
       - run: cpplint --filter=-legal --recursive .
 
   build:
@@ -143,9 +142,6 @@ jobs:
       - uses: actions/checkout@master
         with:
           submodules: true
-      - name: git pull
-        run: git pull
-      - name: configure
-        run: cmake -B ./build -S .
-      - name: build
-        run: cmake --build build
+      - run: git pull
+      - run: cmake -B ./build -S .
+      - run: cmake --build build

From 03d7fa8b67435b5c98135f250804f057b31f7822 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 21:50:07 -0400
Subject: [PATCH 279/290] use master branches for actions

---
 .github/workflows/clang-format.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index 0cfa72e59..df40c4e28 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -1,4 +1,4 @@
-name: Long CI Workflow
+name: Awesome CI Workflow
 
 on: [push]
 #   push:
@@ -125,8 +125,8 @@ jobs:
     needs: code_format
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-python@v1
+      - uses: actions/checkout@master
+      - uses: actions/setup-python@master
       - run: pip install cpplint
       - run: git pull
       - run: cpplint --filter=-legal --recursive .

From b285d09d6a219f7ed22f57f403672e037f379eb8 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 22:20:34 -0400
Subject: [PATCH 280/290] rename .cc files to .cpp

---
 .github/workflows/clang-format.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml
index df40c4e28..121309d1e 100644
--- a/.github/workflows/clang-format.yml
+++ b/.github/workflows/clang-format.yml
@@ -26,7 +26,7 @@ jobs:
       - name: Filename Formatter
         run: |
           IFS=$'\n'
-          for fname in `find . -type f -name '*.cpp' -o -name '*.h'`
+          for fname in `find . -type f -name '*.cpp' -o -name '*.cc' -o -name '*.h'`
           do 
             echo "${fname}"
             new_fname=`echo ${fname} | tr ' ' '_'`
@@ -35,6 +35,8 @@ jobs:
             echo "      ${new_fname}"
             new_fname=`echo ${new_fname} | tr '-' '_'`
             echo "      ${new_fname}"
+            new_fname=${new_fname/.cc/.cpp}
+            echo "      ${new_fname}"
             if [ ${fname} != ${new_fname} ]
             then
               echo "      ${fname} --> ${new_fname}"

From 231d5c48586f41050407a4a0b58e0aff5393ad11 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 23:15:28 -0400
Subject: [PATCH 281/290] added class destructor to clean up dynamic memory
 allocation

---
 dynamic_programming/floyd_warshall.cpp | 47 ++++++++++++--------------
 1 file changed, 22 insertions(+), 25 deletions(-)

diff --git a/dynamic_programming/floyd_warshall.cpp b/dynamic_programming/floyd_warshall.cpp
index e3b0c66d3..d193ebbd5 100644
--- a/dynamic_programming/floyd_warshall.cpp
+++ b/dynamic_programming/floyd_warshall.cpp
@@ -1,44 +1,44 @@
-#include <limits.h>
-#include <string.h>
+#include <climits>
 #include <iostream>
+#include <string>
 
-using namespace std;
+using std::cin;
+using std::cout;
+using std::endl;
 
 // Wrapper class for storing a graph
-class Graph
-{
+class Graph {
  public:
     int vertexNum;
     int **edges;
 
     // Constructs a graph with V vertices and E edges
-    Graph(int V)
-    {
+    Graph(int V) {
         this->vertexNum = V;
-        this->edges = (int **)malloc(V * sizeof(int *));
-        for (int i = 0; i < V; i++)
-        {
-            this->edges[i] = (int *)malloc(V * sizeof(int));
+        this->edges = new int *[V];
+        for (int i = 0; i < V; i++) {
+            this->edges[i] = new int[V];
             for (int j = 0; j < V; j++) this->edges[i][j] = INT_MAX;
             this->edges[i][i] = 0;
         }
     }
 
+    ~Graph() {
+        for (int i = 0; i < vertexNum; i++) delete[] edges[i];
+        delete[] edges;
+    }
+
     // Adds the given edge to the graph
-    void addEdge(int src, int dst, int weight)
-    {
+    void addEdge(int src, int dst, int weight) {
         this->edges[src][dst] = weight;
     }
 };
 
 // Utility function to print distances
-void print(int dist[], int V)
-{
+void print(int dist[], int V) {
     cout << "\nThe Distance matrix for Floyd - Warshall" << endl;
-    for (int i = 0; i < V; i++)
-    {
-        for (int j = 0; j < V; j++)
-        {
+    for (int i = 0; i < V; i++) {
+        for (int j = 0; j < V; j++) {
             if (dist[i * V + j] != INT_MAX)
                 cout << dist[i * V + j] << "\t";
             else
@@ -51,8 +51,7 @@ void print(int dist[], int V)
 
 // The main function that finds the shortest path from a vertex
 // to all other vertices using Floyd-Warshall Algorithm.
-void FloydWarshall(Graph graph)
-{
+void FloydWarshall(Graph graph) {
     int V = graph.vertexNum;
     int dist[V][V];
 
@@ -85,8 +84,7 @@ void FloydWarshall(Graph graph)
 }
 
 // Driver Function
-int main()
-{
+int main() {
     int V, E;
     int src, dst, weight;
     cout << "Enter number of vertices: ";
@@ -94,8 +92,7 @@ int main()
     cout << "Enter number of edges: ";
     cin >> E;
     Graph G(V);
-    for (int i = 0; i < E; i++)
-    {
+    for (int i = 0; i < E; i++) {
         cout << "\nEdge " << i + 1 << "\nEnter source: ";
         cin >> src;
         cout << "Enter destination: ";

From b8a97780a70f86cd1527ac503e5c14466d24dbe0 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 23:42:29 -0400
Subject: [PATCH 282/290] rename to awesome workflow

---
 .github/workflows/{clang-format.yml => awesome_forkflow.yml} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename .github/workflows/{clang-format.yml => awesome_forkflow.yml} (100%)

diff --git a/.github/workflows/clang-format.yml b/.github/workflows/awesome_forkflow.yml
similarity index 100%
rename from .github/workflows/clang-format.yml
rename to .github/workflows/awesome_forkflow.yml

From cac95058297004870981c7e88948079f39e53696 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 23:48:29 -0400
Subject: [PATCH 283/290] commented whole repo cpplint - added modified files
 lint check

---
 .github/workflows/awesome_forkflow.yml | 77 +++++++++++++++++++++++---
 1 file changed, 69 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/awesome_forkflow.yml b/.github/workflows/awesome_forkflow.yml
index 121309d1e..07bfb99dc 100644
--- a/.github/workflows/awesome_forkflow.yml
+++ b/.github/workflows/awesome_forkflow.yml
@@ -122,21 +122,82 @@ jobs:
           git commit -am "updating DIRECTORY.md" ||  true
           git push --force origin HEAD:$GITHUB_REF || true
 
-  cpplint:
-    name: CPPLINT
-    needs: code_format
+  # cpplint:
+  #   name: CPPLINT
+  #   needs: code_format
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@master
+  #     - uses: actions/setup-python@master
+  #     - run: pip install cpplint
+  #     - run: git pull
+  #     - run: cpplint --filter=-legal --recursive .
+  
+  cpplint_modified_files:
     runs-on: ubuntu-latest
+    needs: code_format
+    name: CPPLINT
     steps:
-      - uses: actions/checkout@master
-      - uses: actions/setup-python@master
-      - run: pip install cpplint
+      - uses: actions/checkout@v1 # v2 is broken for git diff
+      - uses: actions/setup-python@v1
+      - run: python -m pip install cpplint
+      - run: git remote -v
+      - run: git branch
+      - run: git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - run: git pull
-      - run: cpplint --filter=-legal --recursive .
+      - run: git diff --diff-filter=dr --name-only origin/master > git_diff.txt
+      - name: cpplint_modified_files
+        shell: python
+        run: |
+          import os
+          import subprocess
+          import sys
+
+          print("Python {}.{}.{}".format(*sys.version_info))  # Python 3.8
+          with open("git_diff.txt") as in_file:
+            modified_files = sorted(in_file.read().splitlines())
+          print("{} files were modified.".format(len(modified_files)))
+
+          cpp_exts = tuple(".c .c++ .cc .cpp .cu .cuh .cxx .h .h++ .hh .hpp .hxx".split())
+          cpp_files = [file for file in modified_files if file.lower().endswith(cpp_exts)]
+          print(f"{len(cpp_files)} C++ files were modified.")
+          if not cpp_files:
+            sys.exit(0)
+
+          print("cpplint:")
+          for cpp_file in cpp_files:
+            subprocess.run(["cpplint", "--filter=-legal/copyright", cpp_file], check=True, text=True)
+
+          print("g++:")
+          # compile_exts = tuple(".c .c++ .cc .cpp .cu .cxx".split())
+          # compile_files = [file for file in cpp_files if file.lower().endswith(compile_exts)]
+          for cpp_file in cpp_files:
+            subprocess.run(["g++", cpp_file], check=True, text=True)
+
+          upper_files = [file for file in cpp_files if file != file.lower()]
+          if upper_files:
+            print(f"{len(upper_files)} files contain uppercase characters:")
+            print("\n".join(upper_files) + "\n")
+
+          space_files = [file for file in cpp_files if " " in file or "-" in file]
+          if space_files:
+            print(f"{len(space_files)} files contain space or dash characters:")
+            print("\n".join(space_files) + "\n")
+
+          nodir_files = [file for file in cpp_files if file.count(os.sep) != 1]
+          if nodir_files:
+            print(f"{len(nodir_files)} files are not in one and only one directory:")
+            print("\n".join(nodir_files) + "\n")
+
+          bad_files = len(upper_files + space_files + nodir_files)
+          if bad_files:
+            sys.exit(bad_files)
+
 
   build:
     name: Compile checks
     runs-on: ${{ matrix.os }}
-    needs: [cpplint, update_directory_md]
+    needs: [cpplint, update_directory_md, cpplint_modified_files]
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]

From 5a737a725df4e46210e0bf31ad3c7d21944ebee6 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 23:50:46 -0400
Subject: [PATCH 284/290] removed need for cpplint

---
 .github/workflows/awesome_forkflow.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/awesome_forkflow.yml b/.github/workflows/awesome_forkflow.yml
index 07bfb99dc..acd53f13c 100644
--- a/.github/workflows/awesome_forkflow.yml
+++ b/.github/workflows/awesome_forkflow.yml
@@ -132,7 +132,7 @@ jobs:
   #     - run: pip install cpplint
   #     - run: git pull
   #     - run: cpplint --filter=-legal --recursive .
-  
+
   cpplint_modified_files:
     runs-on: ubuntu-latest
     needs: code_format
@@ -197,7 +197,8 @@ jobs:
   build:
     name: Compile checks
     runs-on: ${{ matrix.os }}
-    needs: [cpplint, update_directory_md, cpplint_modified_files]
+    # needs: [cpplint, update_directory_md, cpplint_modified_files]
+    needs: [update_directory_md, cpplint_modified_files]
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]

From 2bf0c00e90adac5f3b1e0fca9711a7f1b1cee73a Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Fri, 29 May 2020 23:53:00 -0400
Subject: [PATCH 285/290] attempt to use actions/checkout@master

---
 .github/workflows/awesome_forkflow.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/awesome_forkflow.yml b/.github/workflows/awesome_forkflow.yml
index acd53f13c..8d79e4b71 100644
--- a/.github/workflows/awesome_forkflow.yml
+++ b/.github/workflows/awesome_forkflow.yml
@@ -138,8 +138,8 @@ jobs:
     needs: code_format
     name: CPPLINT
     steps:
-      - uses: actions/checkout@v1 # v2 is broken for git diff
-      - uses: actions/setup-python@v1
+      - uses: actions/checkout@master # v2 is broken for git diff
+      - uses: actions/setup-python@master
       - run: python -m pip install cpplint
       - run: git remote -v
       - run: git branch

From 153fb7b8a572aaf4561ac3d22d47e89480f11318 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sat, 30 May 2020 00:01:27 -0400
Subject: [PATCH 286/290] temporary: no dependency on cpplint

---
 .github/workflows/awesome_forkflow.yml |  4 ++--
 backtracking/knight_tour.cpp           | 25 ++++++++++---------------
 2 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/awesome_forkflow.yml b/.github/workflows/awesome_forkflow.yml
index 8d79e4b71..11e585dee 100644
--- a/.github/workflows/awesome_forkflow.yml
+++ b/.github/workflows/awesome_forkflow.yml
@@ -146,6 +146,7 @@ jobs:
       - run: git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - run: git pull
       - run: git diff --diff-filter=dr --name-only origin/master > git_diff.txt
+      - run: echo "Files changed-- `cat diff.txt`"
       - name: cpplint_modified_files
         shell: python
         run: |
@@ -193,12 +194,11 @@ jobs:
           if bad_files:
             sys.exit(bad_files)
 
-
   build:
     name: Compile checks
     runs-on: ${{ matrix.os }}
     # needs: [cpplint, update_directory_md, cpplint_modified_files]
-    needs: [update_directory_md, cpplint_modified_files]
+    needs: [update_directory_md]
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
diff --git a/backtracking/knight_tour.cpp b/backtracking/knight_tour.cpp
index 72b900376..c97523be7 100644
--- a/backtracking/knight_tour.cpp
+++ b/backtracking/knight_tour.cpp
@@ -9,25 +9,23 @@ square (so that it could tour the board again immediately, following
 the same path), the tour is closed; otherwise, it is open.
 **/
 
-using namespace std;
-bool issafe(int x, int y, int sol[n][n])
-{
+using std::cin;
+using std::cout;
+
+bool issafe(int x, int y, int sol[n][n]) {
     return (x < n && x >= 0 && y < n && y >= 0 && sol[x][y] == -1);
 }
-bool solve(int x, int y, int mov, int sol[n][n], int xmov[n], int ymov[n])
-{
+bool solve(int x, int y, int mov, int sol[n][n], int xmov[n], int ymov[n]) {
     int k, xnext, ynext;
 
     if (mov == n * n)
         return true;
 
-    for (k = 0; k < 8; k++)
-    {
+    for (k = 0; k < 8; k++) {
         xnext = x + xmov[k];
         ynext = y + ymov[k];
 
-        if (issafe(xnext, ynext, sol))
-        {
+        if (issafe(xnext, ynext, sol)) {
             sol[xnext][ynext] = mov;
 
             if (solve(xnext, ynext, mov + 1, sol, xmov, ymov) == true)
@@ -38,8 +36,7 @@ bool solve(int x, int y, int mov, int sol[n][n], int xmov[n], int ymov[n])
     }
     return false;
 }
-int main()
-{
+int main() {
     // initialize();
 
     int sol[n][n];
@@ -54,10 +51,8 @@ int main()
     bool flag = solve(0, 0, 1, sol, xmov, ymov);
     if (flag == false)
         cout << "solution doesnot exist \n";
-    else
-    {
-        for (i = 0; i < n; i++)
-        {
+    else {
+        for (i = 0; i < n; i++) {
             for (j = 0; j < n; j++) cout << sol[i][j] << "  ";
             cout << "\n";
         }

From 92fe9495ecefbdc8e3f70666a7a3c8a5c8cc40c1 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Sat, 30 May 2020 04:02:05 +0000
Subject: [PATCH 287/290] formatting filenames
 153fb7b8a572aaf4561ac3d22d47e89480f11318

---
 graph/{DFS_with_stack.cc => dfs_with_stack.cpp} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename graph/{DFS_with_stack.cc => dfs_with_stack.cpp} (100%)

diff --git a/graph/DFS_with_stack.cc b/graph/dfs_with_stack.cpp
similarity index 100%
rename from graph/DFS_with_stack.cc
rename to graph/dfs_with_stack.cpp

From 8a2de9842baf9d6a4728de2267cb93bdcab81800 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Sat, 30 May 2020 04:02:09 +0000
Subject: [PATCH 288/290] formatting source-code for
 153fb7b8a572aaf4561ac3d22d47e89480f11318

---
 backtracking/graph_coloring.cpp               |  21 ++--
 backtracking/minimax.cpp                      |   6 +-
 backtracking/n_queens.cpp                     |  24 ++--
 .../n_queens_all_solution_optimised.cpp       |  58 +++------
 backtracking/nqueen_print_all_solutions.cpp   |  36 ++----
 backtracking/rat_maze.cpp                     |  31 ++---
 backtracking/sudoku_solve.cpp                 |  57 +++------
 .../bisection_method.cpp                      |  29 ++---
 .../false_position.cpp                        |  25 ++--
 .../gaussian_elimination.cpp                  |  33 ++---
 .../newton_raphson_method.cpp                 |  12 +-
 .../ordinary_least_squares_regressor.cpp      | 112 ++++++-----------
 .../successive_approximation.cpp              |   9 +-
 data_structure/avltree.cpp                    |  50 +++-----
 data_structure/binary_search_tree.cpp         | 119 ++++++------------
 data_structure/binaryheap.cpp                 |  42 +++----
 .../circular_queue_using_linked_list.cpp      |  34 ++---
 data_structure/cll/cll.cpp                    |  67 ++++------
 data_structure/cll/cll.h                      |   6 +-
 data_structure/cll/main_cll.cpp               |   3 +-
 data_structure/disjoint_set.cpp               |  44 +++----
 data_structure/doubly_linked_list.cpp         |  82 ++++--------
 data_structure/linked_list.cpp                |  72 ++++-------
 .../linkedlist_implentation_usingarray.cpp    |  30 ++---
 data_structure/list_array.cpp                 |  95 +++++---------
 data_structure/morrisinorder.cpp              |  44 +++----
 data_structure/queue/queue.cpp                |  42 ++-----
 data_structure/queue/queue.h                  |   6 +-
 data_structure/queue/test_queue.cpp           |   3 +-
 data_structure/queue_using_array.cpp          |  69 +++-------
 data_structure/queue_using_array2.cpp         |  45 +++----
 data_structure/queue_using_linked_list.cpp    |  45 +++----
 data_structure/queue_using_linkedlist.cpp     |  39 ++----
 data_structure/stack_using_array.cpp          |  47 +++----
 data_structure/stack_using_linked_list.cpp    |  39 ++----
 data_structure/stk/main.cpp                   |  16 +--
 data_structure/stk/stack.cpp                  |  44 +++----
 data_structure/stk/stack.h                    |   6 +-
 data_structure/stk/test_stack.cpp             |   3 +-
 data_structure/tree.cpp                       |  53 +++-----
 data_structure/trie_tree.cpp                  |  44 +++----
 dynamic_programming/0_1_knapsack.cpp          |  18 +--
 dynamic_programming/armstrong_number.cpp      |   6 +-
 dynamic_programming/bellman_ford.cpp          |  39 ++----
 dynamic_programming/catalan_numbers.cpp       |  12 +-
 dynamic_programming/coin_change.cpp           |  12 +-
 dynamic_programming/cut_rod.cpp               |  12 +-
 dynamic_programming/edit_distance.cpp         |  15 +--
 dynamic_programming/egg_dropping_puzzle.cpp   |  21 ++--
 dynamic_programming/fibonacci_bottom_up.cpp   |   9 +-
 dynamic_programming/fibonacci_top_down.cpp    |  12 +-
 dynamic_programming/kadane.cpp                |  12 +-
 dynamic_programming/longest_common_string.cpp |  18 +--
 .../longest_common_subsequence.cpp            |  52 +++-----
 .../longest_increasing_subsequence.cpp        |  21 ++--
 ...longest_increasing_subsequence_(nlogn).cpp |  21 ++--
 .../matrix_chain_multiplication.cpp           |  12 +-
 .../searching_of_element_in_dynamic_array.cpp |  12 +-
 dynamic_programming/tree_height.cpp           |  15 +--
 graph/bfs.cpp                                 |  33 ++---
 .../bridge_finding_with_tarjan_algorithm.cpp  |  30 ++---
 graph/connected_components.cpp                |  30 ++---
 graph/connected_components_with_dsu.cpp       |  24 ++--
 graph/dfs.cpp                                 |  15 +--
 graph/dfs_with_stack.cpp                      |  20 ++-
 graph/dijkstra.cpp                            |  18 +--
 graph/kosaraju.cpp                            |  42 +++----
 graph/kruskal.cpp                             |  54 +++-----
 graph/lca.cpp                                 |  66 ++++------
 ...th_ford_fulkerson_and_edmond_karp_algo.cpp |  55 +++-----
 graph/prim.cpp                                |  15 +--
 graph/topological_sort.cpp                    |  21 ++--
 graph/topological_sort_by_kahns_algo.cpp      |  36 ++----
 greedy_algorithms/dijkstra.cpp                |  61 +++------
 greedy_algorithms/huffman.cpp                 |  18 +--
 greedy_algorithms/knapsack.cpp                |  34 ++---
 .../kruskals_minimum_spanning_tree.cpp        |  15 +--
 .../prims_minimum_spanning_tree.cpp           |  39 ++----
 hashing/chaining.cpp                          |  50 +++-----
 hashing/double_hash_hash_table.cpp            | 102 +++++----------
 hashing/linear_probing_hash_table.cpp         |  99 +++++----------
 hashing/quadratic_probing_hash_table.cpp      | 105 +++++-----------
 math/binary_exponent.cpp                      |  36 ++----
 math/double_factorial.cpp                     |  12 +-
 math/eulers_totient_function.cpp              |  22 ++--
 math/extended_euclid_algorithm.cpp            |  22 ++--
 math/factorial.cpp                            |   6 +-
 math/fast_power.cpp                           |  15 +--
 math/fibonacci.cpp                            |   6 +-
 math/fibonacci_fast.cpp                       |   9 +-
 math/fibonacci_large.cpp                      |  16 +--
 math/gcd_iterative_euclidean.cpp              |  29 ++---
 math/gcd_of_n_numbers.cpp                     |   9 +-
 math/gcd_recursive_euclidean.cpp              |  19 +--
 math/large_factorial.cpp                      |  34 ++---
 math/large_number.h                           |  94 +++++---------
 .../modular_inverse_fermat_little_theorem.cpp |  35 ++----
 math/number_of_positive_divisors.cpp          |  31 ++---
 math/power_for_huge_numbers.cpp               |  21 ++--
 math/prime_factorization.cpp                  |  30 ++---
 math/prime_numbers.cpp                        |  12 +-
 math/primes_up_to_billion.cpp                 |  12 +-
 math/sieve_of_eratosthenes.cpp                |  30 ++---
 math/sqrt_double.cpp                          |  22 ++--
 math/string_fibonacci.cpp                     |  34 ++---
 .../array_left_rotation.cpp                   |  22 ++--
 .../array_right_rotation.cpp                  |  19 +--
 .../circular_linked_list.cpp                  |  49 +++-----
 .../circular_queue_using_array.cpp            |  42 ++-----
 .../get_size_of_linked_list.cpp               |  15 +--
 .../intersection_of_2_arrays.cpp              |   9 +-
 .../reverse_a_linked_list_using_recusion.cpp  |  35 ++----
 .../selectionsortlinkedlist.cpp               |  46 +++----
 .../union_of_2_arrays.cpp                     |   9 +-
 others/buzz_number.cpp                        |   6 +-
 others/decimal_to_binary.cpp                  |  15 +--
 others/decimal_to_hexadecimal.cpp             |   6 +-
 others/decimal_to_roman_numeral.cpp           |  12 +-
 others/fast_interger_input.cpp                |   9 +-
 others/happy_number.cpp                       |  14 +--
 others/matrix_exponentiation.cpp              |  49 +++-----
 others/palindrome_of_number.cpp               |   3 +-
 others/paranthesis_matching.cpp               |  30 ++---
 others/pascal_triangle.cpp                    |  27 ++--
 others/primality_test.cpp                     |   9 +-
 others/smallest_circle.cpp                    |  51 +++-----
 others/sparse_matrix.cpp                      |  15 +--
 others/spiral_print.cpp                       |  36 ++----
 others/stairs_pattern.cpp                     |  15 +--
 others/tower_of_hanoi.cpp                     |  34 ++---
 others/vector_important_functions.cpp         |   3 +-
 probability/addition_rule.cpp                 |   9 +-
 probability/bayes_theorem.cpp                 |   9 +-
 probability/binomial_dist.cpp                 |  24 ++--
 probability/poisson_dist.cpp                  |  24 ++--
 range_queries/bit.cpp                         |  27 ++--
 range_queries/fenwicktree.cpp                 |  28 ++---
 range_queries/mo.cpp                          |  33 ++---
 range_queries/segtree.cpp                     |  43 +++----
 search/binary_search.cpp                      |  12 +-
 search/exponential_search.cpp                 |  18 +--
 search/hash_search.cpp                        |  34 ++---
 search/interpolation_search.cpp               |   9 +-
 search/interpolation_search2.cpp              |   9 +-
 search/jump_search.cpp                        |  12 +-
 search/linear_search.cpp                      |  22 ++--
 search/median_search.cpp                      |  36 ++----
 search/ternary_search.cpp                     |  35 ++----
 search/text_search.cpp                        |  20 +--
 sorting/bead_sort.cpp                         |  18 +--
 sorting/bitonic_sort.cpp                      |  18 +--
 sorting/bubble_sort.cpp                       |  25 ++--
 sorting/bucket_sort.cpp                       |   9 +-
 sorting/cocktail_selection_sort.cpp           |  61 +++------
 sorting/comb_sort.cpp                         |  18 +--
 sorting/counting_sort.cpp                     |  18 +--
 sorting/counting_sort_string.cpp              |   9 +-
 sorting/heap_sort.cpp                         |  27 ++--
 sorting/insertion_sort.cpp                    |  15 +--
 sorting/library_sort.cpp                      |  34 ++---
 sorting/merge_sort.cpp                        |  34 ++---
 sorting/non_recursive_merge_sort.cpp          |  24 ++--
 sorting/numeric_string_sort.cpp               |  21 ++--
 sorting/odd_even_sort.cpp                     |  21 ++--
 sorting/quick_sort.cpp                        |  24 ++--
 sorting/radix_sort.cpp                        |  39 ++----
 sorting/selection_sort.cpp                    |  18 +--
 sorting/shell_sort.cpp                        |  25 ++--
 sorting/shell_sort2.cpp                       |  24 ++--
 sorting/slow_sort.cpp                         |  15 +--
 sorting/swap_sort.cpp                         |  18 +--
 sorting/tim_sort.cpp                          |  43 +++----
 strings/brute_force_string_searching.cpp      |  18 +--
 strings/knuth_morris_pratt.cpp                |  35 ++----
 strings/rabin_karp.cpp                        |  37 ++----
 175 files changed, 1671 insertions(+), 3460 deletions(-)

diff --git a/backtracking/graph_coloring.cpp b/backtracking/graph_coloring.cpp
index 5d0049902..19a983019 100644
--- a/backtracking/graph_coloring.cpp
+++ b/backtracking/graph_coloring.cpp
@@ -7,8 +7,7 @@ void printSolution(int color[]);
 
 /* A utility function to check if the current color assignment
    is safe for vertex v */
-bool isSafe(int v, bool graph[V][V], int color[], int c)
-{
+bool isSafe(int v, bool graph[V][V], int color[], int c) {
     for (int i = 0; i < V; i++)
         if (graph[v][i] && c == color[i])
             return false;
@@ -16,22 +15,18 @@ bool isSafe(int v, bool graph[V][V], int color[], int c)
 }
 
 /* A recursive utility function to solve m coloring problem */
-void graphColoring(bool graph[V][V], int m, int color[], int v)
-{
+void graphColoring(bool graph[V][V], int m, int color[], int v) {
     /* base case: If all vertices are assigned a color then
        return true */
-    if (v == V)
-    {
+    if (v == V) {
         printSolution(color);
         return;
     }
 
     /* Consider this vertex v and try different colors */
-    for (int c = 1; c <= m; c++)
-    {
+    for (int c = 1; c <= m; c++) {
         /* Check if assignment of color c to v is fine*/
-        if (isSafe(v, graph, color, c))
-        {
+        if (isSafe(v, graph, color, c)) {
             color[v] = c;
 
             /* recur to assign colors to rest of the vertices */
@@ -45,16 +40,14 @@ void graphColoring(bool graph[V][V], int m, int color[], int v)
 }
 
 /* A utility function to print solution */
-void printSolution(int color[])
-{
+void printSolution(int color[]) {
     printf(" Following are the assigned colors \n");
     for (int i = 0; i < V; i++) printf(" %d ", color[i]);
     printf("\n");
 }
 
 // driver program to test above function
-int main()
-{
+int main() {
     /* Create following graph and test whether it is 3 colorable
       (3)---(2)
        |   / |
diff --git a/backtracking/minimax.cpp b/backtracking/minimax.cpp
index 110e9e7ed..4e46a5fb2 100644
--- a/backtracking/minimax.cpp
+++ b/backtracking/minimax.cpp
@@ -9,8 +9,7 @@ using std::min;
 using std::vector;
 
 int minimax(int depth, int node_index, bool is_max, vector<int> scores,
-            int height)
-{
+            int height) {
     if (depth == height)
         return scores[node_index];
 
@@ -20,8 +19,7 @@ int minimax(int depth, int node_index, bool is_max, vector<int> scores,
     return is_max ? max(v1, v2) : min(v1, v2);
 }
 
-int main()
-{
+int main() {
     vector<int> scores = {90, 23, 6, 33, 21, 65, 123, 34423};
     int height = log2(scores.size());
 
diff --git a/backtracking/n_queens.cpp b/backtracking/n_queens.cpp
index 45d6f436c..8aab5df7b 100644
--- a/backtracking/n_queens.cpp
+++ b/backtracking/n_queens.cpp
@@ -2,18 +2,15 @@
 #define N 4
 using namespace std;
 
-void printSolution(int board[N][N])
-{
+void printSolution(int board[N][N]) {
     cout << "\n";
-    for (int i = 0; i < N; i++)
-    {
+    for (int i = 0; i < N; i++) {
         for (int j = 0; j < N; j++) cout << "" << board[i][j];
         cout << "\n";
     }
 }
 
-bool isSafe(int board[N][N], int row, int col)
-{
+bool isSafe(int board[N][N], int row, int col) {
     int i, j;
 
     /* Check this row on left side */
@@ -34,22 +31,18 @@ bool isSafe(int board[N][N], int row, int col)
     return true;
 }
 
-void solveNQ(int board[N][N], int col)
-{
-    if (col >= N)
-    {
+void solveNQ(int board[N][N], int col) {
+    if (col >= N) {
         printSolution(board);
         return;
     }
 
     /* Consider this column and try placing
        this queen in all rows one by one */
-    for (int i = 0; i < N; i++)
-    {
+    for (int i = 0; i < N; i++) {
         /* Check if queen can be placed on
           board[i][col] */
-        if (isSafe(board, i, col))
-        {
+        if (isSafe(board, i, col)) {
             /* Place this queen in board[i][col] */
             //            cout<<"\n"<<col<<"can place"<<i;
             board[i][col] = 1;
@@ -62,8 +55,7 @@ void solveNQ(int board[N][N], int col)
     }
 }
 
-int main()
-{
+int main() {
     int board[N][N] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
 
     solveNQ(board, 0);
diff --git a/backtracking/n_queens_all_solution_optimised.cpp b/backtracking/n_queens_all_solution_optimised.cpp
index f27b3468b..4f42fba6f 100644
--- a/backtracking/n_queens_all_solution_optimised.cpp
+++ b/backtracking/n_queens_all_solution_optimised.cpp
@@ -2,18 +2,14 @@
 #define n 4
 #define inc_loop(var, start, stop) for (int var = start; var <= stop; var++)
 #define dec_loop(var, start, stop) for (int var = start; var >= stop; var--)
-void PrintSol(int Board[n][n])
-{
-    inc_loop(i, 0, n - 1)
-    {
+void PrintSol(int Board[n][n]) {
+    inc_loop(i, 0, n - 1) {
         inc_loop(j, 0, n - 1) std::cout << Board[i][j] << " ";
         std::cout << std::endl;
     }
     std::cout << std::endl;
-    if (n % 2 == 0 || (n % 2 == 1 && Board[n / 2 + 1][0] != 1))
-    {
-        inc_loop(i, 0, n - 1)
-        {
+    if (n % 2 == 0 || (n % 2 == 1 && Board[n / 2 + 1][0] != 1)) {
+        inc_loop(i, 0, n - 1) {
             dec_loop(j, n - 1, 0) std::cout << Board[i][j] << " ";
             std::cout << std::endl;
         }
@@ -21,40 +17,32 @@ void PrintSol(int Board[n][n])
     }
 }
 
-bool CanIMove(int Board[n][n], int row, int col)
-{
+bool CanIMove(int Board[n][n], int row, int col) {
     /// check in the row
-    inc_loop(i, 0, col - 1)
-    {
+    inc_loop(i, 0, col - 1) {
         if (Board[row][i] == 1)
             return false;
     }
     /// check the first diagonal
-    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
-    {
+    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
         if (Board[i][j] == 1)
             return false;
     }
     /// check the second diagonal
-    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--)
-    {
+    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--) {
         if (Board[i][j] == 1)
             return false;
     }
     return true;
 }
 
-void NQueenSol(int Board[n][n], int col)
-{
-    if (col >= n)
-    {
+void NQueenSol(int Board[n][n], int col) {
+    if (col >= n) {
         PrintSol(Board);
         return;
     }
-    inc_loop(i, 0, n - 1)
-    {
-        if (CanIMove(Board, i, col))
-        {
+    inc_loop(i, 0, n - 1) {
+        if (CanIMove(Board, i, col)) {
             Board[i][col] = 1;
             NQueenSol(Board, col + 1);
             Board[i][col] = 0;
@@ -62,27 +50,19 @@ void NQueenSol(int Board[n][n], int col)
     }
 }
 
-int main()
-{
+int main() {
     int Board[n][n] = {0};
-    if (n % 2 == 0)
-    {
-        inc_loop(i, 0, n / 2 - 1)
-        {
-            if (CanIMove(Board, i, 0))
-            {
+    if (n % 2 == 0) {
+        inc_loop(i, 0, n / 2 - 1) {
+            if (CanIMove(Board, i, 0)) {
                 Board[i][0] = 1;
                 NQueenSol(Board, 1);
                 Board[i][0] = 0;
             }
         }
-    }
-    else
-    {
-        inc_loop(i, 0, n / 2)
-        {
-            if (CanIMove(Board, i, 0))
-            {
+    } else {
+        inc_loop(i, 0, n / 2) {
+            if (CanIMove(Board, i, 0)) {
                 Board[i][0] = 1;
                 NQueenSol(Board, 1);
                 Board[i][0] = 0;
diff --git a/backtracking/nqueen_print_all_solutions.cpp b/backtracking/nqueen_print_all_solutions.cpp
index d3d50998d..e6736da1e 100644
--- a/backtracking/nqueen_print_all_solutions.cpp
+++ b/backtracking/nqueen_print_all_solutions.cpp
@@ -1,12 +1,9 @@
 #include <iostream>
 #define n 4
 
-void PrintSol(int Board[n][n])
-{
-    for (int i = 0; i < n; i++)
-    {
-        for (int j = 0; j < n; j++)
-        {
+void PrintSol(int Board[n][n]) {
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
             std::cout << Board[i][j] << " ";
         }
         std::cout << std::endl;
@@ -14,40 +11,32 @@ void PrintSol(int Board[n][n])
     std::cout << std::endl;
 }
 
-bool CanIMove(int Board[n][n], int row, int col)
-{
+bool CanIMove(int Board[n][n], int row, int col) {
     /// check in the row
-    for (int i = 0; i < col; i++)
-    {
+    for (int i = 0; i < col; i++) {
         if (Board[row][i] == 1)
             return false;
     }
     /// check the first diagonal
-    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--)
-    {
+    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
         if (Board[i][j] == 1)
             return false;
     }
     /// check the second diagonal
-    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--)
-    {
+    for (int i = row, j = col; i <= n - 1 && j >= 0; i++, j--) {
         if (Board[i][j] == 1)
             return false;
     }
     return true;
 }
 
-void NQueenSol(int Board[n][n], int col)
-{
-    if (col >= n)
-    {
+void NQueenSol(int Board[n][n], int col) {
+    if (col >= n) {
         PrintSol(Board);
         return;
     }
-    for (int i = 0; i < n; i++)
-    {
-        if (CanIMove(Board, i, col))
-        {
+    for (int i = 0; i < n; i++) {
+        if (CanIMove(Board, i, col)) {
             Board[i][col] = 1;
             NQueenSol(Board, col + 1);
             Board[i][col] = 0;
@@ -55,8 +44,7 @@ void NQueenSol(int Board[n][n], int col)
     }
 }
 
-int main()
-{
+int main() {
     int Board[n][n] = {0};
     NQueenSol(Board, 0);
 }
diff --git a/backtracking/rat_maze.cpp b/backtracking/rat_maze.cpp
index 5454a6c82..fb3be4451 100644
--- a/backtracking/rat_maze.cpp
+++ b/backtracking/rat_maze.cpp
@@ -12,36 +12,28 @@
 using namespace std;
 
 int solveMaze(int currposrow, int currposcol, int maze[size][size],
-              int soln[size][size])
-{
-    if ((currposrow == size - 1) && (currposcol == size - 1))
-    {
+              int soln[size][size]) {
+    if ((currposrow == size - 1) && (currposcol == size - 1)) {
         soln[currposrow][currposcol] = 1;
-        for (int i = 0; i < size; ++i)
-        {
-            for (int j = 0; j < size; ++j)
-            {
+        for (int i = 0; i < size; ++i) {
+            for (int j = 0; j < size; ++j) {
                 cout << soln[i][j];
             }
             cout << endl;
         }
         return 1;
-    }
-    else
-    {
+    } else {
         soln[currposrow][currposcol] = 1;
 
         // if there exist a solution by moving one step ahead in a collumn
         if ((currposcol < size - 1) && maze[currposrow][currposcol + 1] == 1 &&
-            solveMaze(currposrow, currposcol + 1, maze, soln))
-        {
+            solveMaze(currposrow, currposcol + 1, maze, soln)) {
             return 1;
         }
 
         // if there exists a solution by moving one step ahead in a row
         if ((currposrow < size - 1) && maze[currposrow + 1][currposcol] == 1 &&
-            solveMaze(currposrow + 1, currposcol, maze, soln))
-        {
+            solveMaze(currposrow + 1, currposcol, maze, soln)) {
             return 1;
         }
 
@@ -51,17 +43,14 @@ int solveMaze(int currposrow, int currposcol, int maze[size][size],
     }
 }
 
-int main(int argc, char const *argv[])
-{
+int main(int argc, char const *argv[]) {
     int maze[size][size] = {
         {1, 0, 1, 0}, {1, 0, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 1}};
 
     int soln[size][size];
 
-    for (int i = 0; i < size; ++i)
-    {
-        for (int j = 0; j < size; ++j)
-        {
+    for (int i = 0; i < size; ++i) {
+        for (int j = 0; j < size; ++j) {
             soln[i][j] = 0;
         }
     }
diff --git a/backtracking/sudoku_solve.cpp b/backtracking/sudoku_solve.cpp
index c98040841..b712b6ec7 100644
--- a/backtracking/sudoku_solve.cpp
+++ b/backtracking/sudoku_solve.cpp
@@ -3,13 +3,10 @@ using namespace std;
 /// N=9;
 int n = 9;
 
-bool isPossible(int mat[][9], int i, int j, int no)
-{
+bool isPossible(int mat[][9], int i, int j, int no) {
     /// Row or col nahin hona chahiye
-    for (int x = 0; x < n; x++)
-    {
-        if (mat[x][j] == no || mat[i][x] == no)
-        {
+    for (int x = 0; x < n; x++) {
+        if (mat[x][j] == no || mat[i][x] == no) {
             return false;
         }
     }
@@ -18,12 +15,9 @@ bool isPossible(int mat[][9], int i, int j, int no)
     int sx = (i / 3) * 3;
     int sy = (j / 3) * 3;
 
-    for (int x = sx; x < sx + 3; x++)
-    {
-        for (int y = sy; y < sy + 3; y++)
-        {
-            if (mat[x][y] == no)
-            {
+    for (int x = sx; x < sx + 3; x++) {
+        for (int y = sy; y < sy + 3; y++) {
+            if (mat[x][y] == no) {
                 return false;
             }
         }
@@ -31,58 +25,46 @@ bool isPossible(int mat[][9], int i, int j, int no)
 
     return true;
 }
-void printMat(int mat[][9])
-{
-    for (int i = 0; i < n; i++)
-    {
-        for (int j = 0; j < n; j++)
-        {
+void printMat(int mat[][9]) {
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
             cout << mat[i][j] << " ";
-            if ((j + 1) % 3 == 0)
-            {
+            if ((j + 1) % 3 == 0) {
                 cout << '\t';
             }
         }
-        if ((i + 1) % 3 == 0)
-        {
+        if ((i + 1) % 3 == 0) {
             cout << endl;
         }
         cout << endl;
     }
 }
 
-bool solveSudoku(int mat[][9], int i, int j)
-{
+bool solveSudoku(int mat[][9], int i, int j) {
     /// Base Case
-    if (i == 9)
-    {
+    if (i == 9) {
         /// Solve kr chuke hain for 9 rows already
         printMat(mat);
         return true;
     }
 
     /// Crossed the last  Cell in the row
-    if (j == 9)
-    {
+    if (j == 9) {
         return solveSudoku(mat, i + 1, 0);
     }
 
     /// Blue Cell - Skip
-    if (mat[i][j] != 0)
-    {
+    if (mat[i][j] != 0) {
         return solveSudoku(mat, i, j + 1);
     }
     /// White Cell
     /// Try to place every possible no
-    for (int no = 1; no <= 9; no++)
-    {
-        if (isPossible(mat, i, j, no))
-        {
+    for (int no = 1; no <= 9; no++) {
+        if (isPossible(mat, i, j, no)) {
             /// Place the no - assuming solution aa jayega
             mat[i][j] = no;
             bool aageKiSolveHui = solveSudoku(mat, i, j + 1);
-            if (aageKiSolveHui)
-            {
+            if (aageKiSolveHui) {
                 return true;
             }
             /// Nahin solve hui
@@ -94,8 +76,7 @@ bool solveSudoku(int mat[][9], int i, int j)
     return false;
 }
 
-int main()
-{
+int main() {
     int mat[9][9] = {{5, 3, 0, 0, 7, 0, 0, 0, 0}, {6, 0, 0, 1, 9, 5, 0, 0, 0},
                      {0, 9, 8, 0, 0, 0, 0, 6, 0}, {8, 0, 0, 0, 6, 0, 0, 0, 3},
                      {4, 0, 0, 8, 0, 3, 0, 0, 1}, {7, 0, 0, 0, 2, 0, 0, 0, 6},
diff --git a/computer_oriented_statistical_methods/bisection_method.cpp b/computer_oriented_statistical_methods/bisection_method.cpp
index ea0a5e931..c93c529d2 100644
--- a/computer_oriented_statistical_methods/bisection_method.cpp
+++ b/computer_oriented_statistical_methods/bisection_method.cpp
@@ -23,36 +23,29 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i)
-{
+static double eq(double i) {
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
 /** get the sign of any given number */
 template <typename T>
-int sgn(T val)
-{
+int sgn(T val) {
     return (T(0) < val) - (val < T(0));
 }
 
 /** main function */
-int main()
-{
+int main() {
     double a = -1, b = 1, x, z;
     int i;
 
     // loop to find initial intervals a, b
-    for (int i = 0; i < MAX_ITERATIONS; i++)
-    {
+    for (int i = 0; i < MAX_ITERATIONS; i++) {
         z = eq(a);
         x = eq(b);
-        if (sgn(z) == sgn(x))
-        {  // same signs, increase interval
+        if (sgn(z) == sgn(x)) {  // same signs, increase interval
             b++;
             a--;
-        }
-        else
-        {  // if opposite signs, we got our interval
+        } else {  // if opposite signs, we got our interval
             break;
         }
     }
@@ -61,19 +54,15 @@ int main()
     std::cout << "\nSecond initial: " << b;
 
     // start iterations
-    for (i = 0; i < MAX_ITERATIONS; i++)
-    {
+    for (i = 0; i < MAX_ITERATIONS; i++) {
         x = (a + b) / 2;
         z = eq(x);
         std::cout << "\n\nz: " << z << "\t[" << a << " , " << b
                   << " | Bisect: " << x << "]";
 
-        if (z < 0)
-        {
+        if (z < 0) {
             a = x;
-        }
-        else
-        {
+        } else {
             b = x;
         }
 
diff --git a/computer_oriented_statistical_methods/false_position.cpp b/computer_oriented_statistical_methods/false_position.cpp
index 6bdc0cf67..aebd154bb 100644
--- a/computer_oriented_statistical_methods/false_position.cpp
+++ b/computer_oriented_statistical_methods/false_position.cpp
@@ -25,36 +25,29 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i)
-{
+static double eq(double i) {
     return (std::pow(i, 3) - (4 * i) - 9);  // origial equation
 }
 
 /** get the sign of any given number */
 template <typename T>
-int sgn(T val)
-{
+int sgn(T val) {
     return (T(0) < val) - (val < T(0));
 }
 
 /** main function */
-int main()
-{
+int main() {
     double a = -1, b = 1, x, z, m, n, c;
     int i;
 
     // loop to find initial intervals a, b
-    for (int i = 0; i < MAX_ITERATIONS; i++)
-    {
+    for (int i = 0; i < MAX_ITERATIONS; i++) {
         z = eq(a);
         x = eq(b);
-        if (sgn(z) == sgn(x))
-        {  // same signs, increase interval
+        if (sgn(z) == sgn(x)) {  // same signs, increase interval
             b++;
             a--;
-        }
-        else
-        {  // if opposite signs, we got our interval
+        } else {  // if opposite signs, we got our interval
             break;
         }
     }
@@ -62,8 +55,7 @@ int main()
     std::cout << "\nFirst initial: " << a;
     std::cout << "\nSecond initial: " << b;
 
-    for (i = 0; i < MAX_ITERATIONS; i++)
-    {
+    for (i = 0; i < MAX_ITERATIONS; i++) {
         m = eq(a);
         n = eq(b);
 
@@ -72,8 +64,7 @@ int main()
         a = c;
         z = eq(c);
 
-        if (std::abs(z) < EPSILON)
-        {  // stoping criteria
+        if (std::abs(z) < EPSILON) {  // stoping criteria
             break;
         }
     }
diff --git a/computer_oriented_statistical_methods/gaussian_elimination.cpp b/computer_oriented_statistical_methods/gaussian_elimination.cpp
index 01cb578b2..60b5648ec 100644
--- a/computer_oriented_statistical_methods/gaussian_elimination.cpp
+++ b/computer_oriented_statistical_methods/gaussian_elimination.cpp
@@ -6,8 +6,7 @@
 #include <iostream>
 
 /** Main function */
-int main()
-{
+int main() {
     int mat_size, i, j, step;
 
     std::cout << "Matrix size: ";
@@ -15,8 +14,7 @@ int main()
 
     // create a 2D matrix by dynamic memory allocation
     double **mat = new double *[mat_size + 1], **x = new double *[mat_size];
-    for (i = 0; i <= mat_size; i++)
-    {
+    for (i = 0; i <= mat_size; i++) {
         mat[i] = new double[mat_size + 1];
         if (i < mat_size)
             x[i] = new double[mat_size + 1];
@@ -24,20 +22,16 @@ int main()
 
     // get the matrix elements from user
     std::cout << std::endl << "Enter value of the matrix: " << std::endl;
-    for (i = 0; i < mat_size; i++)
-    {
-        for (j = 0; j <= mat_size; j++)
-        {
+    for (i = 0; i < mat_size; i++) {
+        for (j = 0; j <= mat_size; j++) {
             std::cin >>
                 mat[i][j];  // Enter (mat_size*mat_size) value of the matrix.
         }
     }
 
     // perform Gaussian elimination
-    for (step = 0; step < mat_size - 1; step++)
-    {
-        for (i = step; i < mat_size - 1; i++)
-        {
+    for (step = 0; step < mat_size - 1; step++) {
+        for (i = step; i < mat_size - 1; i++) {
             double a = (mat[i + 1][step] / mat[step][step]);
 
             for (j = step; j <= mat_size; j++)
@@ -47,10 +41,8 @@ int main()
 
     std::cout << std::endl
               << "Matrix using Gaussian Elimination method: " << std::endl;
-    for (i = 0; i < mat_size; i++)
-    {
-        for (j = 0; j <= mat_size; j++)
-        {
+    for (i = 0; i < mat_size; i++) {
+        for (j = 0; j <= mat_size; j++) {
             x[i][j] = mat[i][j];
             std::cout << mat[i][j] << " ";
         }
@@ -58,11 +50,9 @@ int main()
     }
     std::cout << std::endl
               << "Value of the Gaussian Elimination method: " << std::endl;
-    for (i = mat_size - 1; i >= 0; i--)
-    {
+    for (i = mat_size - 1; i >= 0; i--) {
         double sum = 0;
-        for (j = mat_size - 1; j > i; j--)
-        {
+        for (j = mat_size - 1; j > i; j--) {
             x[i][j] = x[j][j] * x[i][j];
             sum = x[i][j] + sum;
         }
@@ -74,8 +64,7 @@ int main()
         std::cout << "x" << i << "= " << x[i][i] << std::endl;
     }
 
-    for (i = 0; i <= mat_size; i++)
-    {
+    for (i = 0; i <= mat_size; i++) {
         delete[] mat[i];
         if (i < mat_size)
             delete[] x[i];
diff --git a/computer_oriented_statistical_methods/newton_raphson_method.cpp b/computer_oriented_statistical_methods/newton_raphson_method.cpp
index a93774b91..318363a39 100644
--- a/computer_oriented_statistical_methods/newton_raphson_method.cpp
+++ b/computer_oriented_statistical_methods/newton_raphson_method.cpp
@@ -21,21 +21,18 @@
 
 /** define \f$f(x)\f$ to find root for
  */
-static double eq(double i)
-{
+static double eq(double i) {
     return (std::pow(i, 3) - (4 * i) - 9);  // original equation
 }
 
 /** define the derivative function \f$f'(x)\f$
  */
-static double eq_der(double i)
-{
+static double eq_der(double i) {
     return ((3 * std::pow(i, 2)) - 4);  // derivative of equation
 }
 
 /** Main function */
-int main()
-{
+int main() {
     std::srand(std::time(nullptr));  // initialize randomizer
 
     double z, c = std::rand() % 100, m, n;
@@ -44,8 +41,7 @@ int main()
     std::cout << "\nInitial approximation: " << c;
 
     // start iterations
-    for (i = 0; i < MAX_ITERATIONS; i++)
-    {
+    for (i = 0; i < MAX_ITERATIONS; i++) {
         m = eq(c);
         n = eq_der(c);
 
diff --git a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
index c3fe8be03..de02b27bb 100644
--- a/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
+++ b/computer_oriented_statistical_methods/ordinary_least_squares_regressor.cpp
@@ -16,13 +16,11 @@
  */
 template <typename T>
 std::ostream &operator<<(std::ostream &out,
-                         std::vector<std::vector<T>> const &v)
-{
+                         std::vector<std::vector<T>> const &v) {
     const int width = 10;
     const char separator = ' ';
 
-    for (size_t row = 0; row < v.size(); row++)
-    {
+    for (size_t row = 0; row < v.size(); row++) {
         for (size_t col = 0; col < v[row].size(); col++)
             out << std::left << std::setw(width) << std::setfill(separator)
                 << v[row][col];
@@ -36,8 +34,7 @@ std::ostream &operator<<(std::ostream &out,
  * operator to print a vector
  */
 template <typename T>
-std::ostream &operator<<(std::ostream &out, std::vector<T> const &v)
-{
+std::ostream &operator<<(std::ostream &out, std::vector<T> const &v) {
     const int width = 15;
     const char separator = ' ';
 
@@ -53,8 +50,7 @@ std::ostream &operator<<(std::ostream &out, std::vector<T> const &v)
  * \returns 1 if true, 0 if false
  */
 template <typename T>
-inline bool is_square(std::vector<std::vector<T>> const &A)
-{
+inline bool is_square(std::vector<std::vector<T>> const &A) {
     // Assuming A is square matrix
     size_t N = A.size();
     for (size_t i = 0; i < N; i++)
@@ -72,8 +68,7 @@ inline bool is_square(std::vector<std::vector<T>> const &A)
  **/
 template <typename T>
 std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
-                                      std::vector<std::vector<T>> const &B)
-{
+                                      std::vector<std::vector<T>> const &B) {
     // Number of rows in A
     size_t N_A = A.size();
     // Number of columns in B
@@ -81,18 +76,15 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
 
     std::vector<std::vector<T>> result(N_A);
 
-    if (A[0].size() != B.size())
-    {
+    if (A[0].size() != B.size()) {
         std::cerr << "Number of columns in A != Number of rows in B ("
                   << A[0].size() << ", " << B.size() << ")" << std::endl;
         return result;
     }
 
-    for (size_t row = 0; row < N_A; row++)
-    {
+    for (size_t row = 0; row < N_A; row++) {
         std::vector<T> v(N_B);
-        for (size_t col = 0; col < N_B; col++)
-        {
+        for (size_t col = 0; col < N_B; col++) {
             v[col] = static_cast<T>(0);
             for (size_t j = 0; j < B.size(); j++)
                 v[col] += A[row][j] * B[j][col];
@@ -109,22 +101,19 @@ std::vector<std::vector<T>> operator*(std::vector<std::vector<T>> const &A,
  */
 template <typename T>
 std::vector<T> operator*(std::vector<std::vector<T>> const &A,
-                         std::vector<T> const &B)
-{
+                         std::vector<T> const &B) {
     // Number of rows in A
     size_t N_A = A.size();
 
     std::vector<T> result(N_A);
 
-    if (A[0].size() != B.size())
-    {
+    if (A[0].size() != B.size()) {
         std::cerr << "Number of columns in A != Number of rows in B ("
                   << A[0].size() << ", " << B.size() << ")" << std::endl;
         return result;
     }
 
-    for (size_t row = 0; row < N_A; row++)
-    {
+    for (size_t row = 0; row < N_A; row++) {
         result[row] = static_cast<T>(0);
         for (size_t j = 0; j < B.size(); j++) result[row] += A[row][j] * B[j];
     }
@@ -137,15 +126,13 @@ std::vector<T> operator*(std::vector<std::vector<T>> const &A,
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator*(float const scalar, std::vector<T> const &A)
-{
+std::vector<float> operator*(float const scalar, std::vector<T> const &A) {
     // Number of rows in A
     size_t N_A = A.size();
 
     std::vector<float> result(N_A);
 
-    for (size_t row = 0; row < N_A; row++)
-    {
+    for (size_t row = 0; row < N_A; row++) {
         result[row] += A[row] * static_cast<float>(scalar);
     }
 
@@ -157,8 +144,7 @@ std::vector<float> operator*(float const scalar, std::vector<T> const &A)
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator*(std::vector<T> const &A, float const scalar)
-{
+std::vector<float> operator*(std::vector<T> const &A, float const scalar) {
     // Number of rows in A
     size_t N_A = A.size();
 
@@ -175,8 +161,7 @@ std::vector<float> operator*(std::vector<T> const &A, float const scalar)
  * \returns resultant vector
  */
 template <typename T>
-std::vector<float> operator/(std::vector<T> const &A, float const scalar)
-{
+std::vector<float> operator/(std::vector<T> const &A, float const scalar) {
     return (1.f / scalar) * A;
 }
 
@@ -185,15 +170,13 @@ std::vector<float> operator/(std::vector<T> const &A, float const scalar)
  * \returns resultant vector
  */
 template <typename T>
-std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B)
-{
+std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B) {
     // Number of rows in A
     size_t N = A.size();
 
     std::vector<T> result(N);
 
-    if (B.size() != N)
-    {
+    if (B.size() != N) {
         std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
         return A;
     }
@@ -208,15 +191,13 @@ std::vector<T> operator-(std::vector<T> const &A, std::vector<T> const &B)
  * \returns resultant vector
  */
 template <typename T>
-std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B)
-{
+std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B) {
     // Number of rows in A
     size_t N = A.size();
 
     std::vector<T> result(N);
 
-    if (B.size() != N)
-    {
+    if (B.size() != N) {
         std::cerr << "Vector dimensions shouldbe identical!" << std::endl;
         return A;
     }
@@ -233,30 +214,26 @@ std::vector<T> operator+(std::vector<T> const &A, std::vector<T> const &B)
  **/
 template <typename T>
 std::vector<std::vector<float>> get_inverse(
-    std::vector<std::vector<T>> const &A)
-{
+    std::vector<std::vector<T>> const &A) {
     // Assuming A is square matrix
     size_t N = A.size();
 
     std::vector<std::vector<float>> inverse(N);
-    for (size_t row = 0; row < N; row++)
-    {
+    for (size_t row = 0; row < N; row++) {
         // preallocatae a resultant identity matrix
         inverse[row] = std::vector<float>(N);
         for (size_t col = 0; col < N; col++)
             inverse[row][col] = (row == col) ? 1.f : 0.f;
     }
 
-    if (!is_square(A))
-    {
+    if (!is_square(A)) {
         std::cerr << "A must be a square matrix!" << std::endl;
         return inverse;
     }
 
     // preallocatae a temporary matrix identical to A
     std::vector<std::vector<float>> temp(N);
-    for (size_t row = 0; row < N; row++)
-    {
+    for (size_t row = 0; row < N; row++) {
         std::vector<float> v(N);
         for (size_t col = 0; col < N; col++)
             v[col] = static_cast<float>(A[row][col]);
@@ -264,27 +241,22 @@ std::vector<std::vector<float>> get_inverse(
     }
 
     // start transformations
-    for (size_t row = 0; row < N; row++)
-    {
-        for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++)
-        {
+    for (size_t row = 0; row < N; row++) {
+        for (size_t row2 = row; row2 < N && temp[row][row] == 0; row2++) {
             // this to ensure diagonal elements are not 0
             temp[row] = temp[row] + temp[row2];
             inverse[row] = inverse[row] + inverse[row2];
         }
 
-        for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++)
-        {
+        for (size_t col2 = row; col2 < N && temp[row][row] == 0; col2++) {
             // this to further ensure diagonal elements are not 0
-            for (size_t row2 = 0; row2 < N; row2++)
-            {
+            for (size_t row2 = 0; row2 < N; row2++) {
                 temp[row2][row] = temp[row2][row] + temp[row2][col2];
                 inverse[row2][row] = inverse[row2][row] + inverse[row2][col2];
             }
         }
 
-        if (temp[row][row] == 0)
-        {
+        if (temp[row][row] == 0) {
             // Probably a low-rank matrix and hence singular
             std::cerr << "Low-rank matrix, no inverse!" << std::endl;
             return inverse;
@@ -295,8 +267,7 @@ std::vector<std::vector<float>> get_inverse(
         temp[row] = temp[row] / divisor;
         inverse[row] = inverse[row] / divisor;
         // Row transformations
-        for (size_t row2 = 0; row2 < N; row2++)
-        {
+        for (size_t row2 = 0; row2 < N; row2++) {
             if (row2 == row)
                 continue;
             float factor = temp[row2][row];
@@ -313,12 +284,11 @@ std::vector<std::vector<float>> get_inverse(
  * \returns resultant matrix
  **/
 template <typename T>
-std::vector<std::vector<T>> get_transpose(std::vector<std::vector<T>> const &A)
-{
+std::vector<std::vector<T>> get_transpose(
+    std::vector<std::vector<T>> const &A) {
     std::vector<std::vector<T>> result(A[0].size());
 
-    for (size_t row = 0; row < A[0].size(); row++)
-    {
+    for (size_t row = 0; row < A[0].size(); row++) {
         std::vector<T> v(A.size());
         for (size_t col = 0; col < A.size(); col++) v[col] = A[col][row];
 
@@ -336,8 +306,7 @@ std::vector<std::vector<T>> get_transpose(std::vector<std::vector<T>> const &A)
  */
 template <typename T>
 std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
-                                     std::vector<T> const &Y)
-{
+                                     std::vector<T> const &Y) {
     // NxF
     std::vector<std::vector<T>> X2 = X;
     for (size_t i = 0; i < X2.size(); i++)
@@ -368,12 +337,10 @@ std::vector<float> fit_OLS_regressor(std::vector<std::vector<T>> const &X,
 template <typename T>
 std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
                                          std::vector<float> const &beta /**< */
-)
-{
+) {
     std::vector<float> result(X.size());
 
-    for (size_t rows = 0; rows < X.size(); rows++)
-    {
+    for (size_t rows = 0; rows < X.size(); rows++) {
         // -> start with constant term
         result[rows] = beta[X[0].size()];
         for (size_t cols = 0; cols < X[0].size(); cols++)
@@ -386,8 +353,7 @@ std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
 /**
  * main function
  */
-int main()
-{
+int main() {
     size_t N, F;
 
     std::cout << "Enter number of features: ";
@@ -404,8 +370,7 @@ int main()
         << "Enter training data. Per sample, provide features ad one output."
         << std::endl;
 
-    for (size_t rows = 0; rows < N; rows++)
-    {
+    for (size_t rows = 0; rows < N; rows++) {
         std::vector<float> v(F);
         std::cout << "Sample# " << rows + 1 << ": ";
         for (size_t cols = 0; cols < F; cols++)
@@ -426,8 +391,7 @@ int main()
     std::vector<std::vector<float>> data2(T);
     // vector<float> Y2(T);
 
-    for (size_t rows = 0; rows < T; rows++)
-    {
+    for (size_t rows = 0; rows < T; rows++) {
         std::cout << "Sample# " << rows + 1 << ": ";
         std::vector<float> v(F);
         for (size_t cols = 0; cols < F; cols++) std::cin >> v[cols];
diff --git a/computer_oriented_statistical_methods/successive_approximation.cpp b/computer_oriented_statistical_methods/successive_approximation.cpp
index 137933591..351382f24 100644
--- a/computer_oriented_statistical_methods/successive_approximation.cpp
+++ b/computer_oriented_statistical_methods/successive_approximation.cpp
@@ -17,13 +17,11 @@ static float eq(float y) { return (3 * y) - cos(y) - 2; }
 static float eqd(float y) { return 0.5 * (cos(y) + 2); }
 
 /** Main function */
-int main()
-{
+int main() {
     float y, x1, x2, x3, sum, s, a, f1, f2, gd;
     int i, n;
 
-    for (i = 0; i < 10; i++)
-    {
+    for (i = 0; i < 10; i++) {
         sum = eq(y);
         std::cout << "value of equation at " << i << " " << sum << "\n";
         y++;
@@ -33,8 +31,7 @@ int main()
     std::cout << "enter the no iteration to perform->\n";
     std::cin >> n;
 
-    for (i = 0; i <= n; i++)
-    {
+    for (i = 0; i <= n; i++) {
         x2 = eqd(x1);
         std::cout << "\nenter the x2->" << x2;
         x1 = x2;
diff --git a/data_structure/avltree.cpp b/data_structure/avltree.cpp
index dc96ad977..f38133c05 100644
--- a/data_structure/avltree.cpp
+++ b/data_structure/avltree.cpp
@@ -3,8 +3,7 @@
 
 using namespace std;
 
-typedef struct node
-{
+typedef struct node {
     int data;
     int height;
     struct node *left;
@@ -15,8 +14,7 @@ int max(int a, int b) { return a > b ? a : b; }
 
 // Returns a new Node
 
-node *createNode(int data)
-{
+node *createNode(int data) {
     node *nn = new node();
     nn->data = data;
     nn->height = 0;
@@ -27,8 +25,7 @@ node *createNode(int data)
 
 // Returns height of tree
 
-int height(node *root)
-{
+int height(node *root) {
     if (root == NULL)
         return 0;
     return 1 + max(height(root->left), height(root->right));
@@ -40,8 +37,7 @@ int getBalance(node *root) { return height(root->left) - height(root->right); }
 
 // Returns Node after Right Rotation
 
-node *rightRotate(node *root)
-{
+node *rightRotate(node *root) {
     node *t = root->left;
     node *u = t->right;
     t->right = root;
@@ -51,8 +47,7 @@ node *rightRotate(node *root)
 
 // Returns Node after Left Rotation
 
-node *leftRotate(node *root)
-{
+node *leftRotate(node *root) {
     node *t = root->right;
     node *u = t->left;
     t->left = root;
@@ -62,8 +57,7 @@ node *leftRotate(node *root)
 
 // Returns node with minimum value in the tree
 
-node *minValue(node *root)
-{
+node *minValue(node *root) {
     if (root->left == NULL)
         return root;
     return minValue(root->left);
@@ -71,8 +65,7 @@ node *minValue(node *root)
 
 // Balanced Insertion
 
-node *insert(node *root, int item)
-{
+node *insert(node *root, int item) {
     node *nn = createNode(item);
     if (root == NULL)
         return nn;
@@ -81,14 +74,11 @@ node *insert(node *root, int item)
     else
         root->right = insert(root->right, item);
     int b = getBalance(root);
-    if (b > 1)
-    {
+    if (b > 1) {
         if (getBalance(root->left) < 0)
             root->left = leftRotate(root->left);  // Left-Right Case
         return rightRotate(root);                 // Left-Left Case
-    }
-    else if (b < -1)
-    {
+    } else if (b < -1) {
         if (getBalance(root->right) > 0)
             root->right = rightRotate(root->right);  // Right-Left Case
         return leftRotate(root);                     // Right-Right Case
@@ -98,8 +88,7 @@ node *insert(node *root, int item)
 
 // Balanced Deletion
 
-node *deleteNode(node *root, int key)
-{
+node *deleteNode(node *root, int key) {
     if (root == NULL)
         return root;
     if (key < root->data)
@@ -107,18 +96,14 @@ node *deleteNode(node *root, int key)
     else if (key > root->data)
         root->right = deleteNode(root->right, key);
 
-    else
-    {
+    else {
         // Node to be deleted is leaf node or have only one Child
-        if (!root->right)
-        {
+        if (!root->right) {
             node *temp = root->left;
             delete (root);
             root = NULL;
             return temp;
-        }
-        else if (!root->left)
-        {
+        } else if (!root->left) {
             node *temp = root->right;
             delete (root);
             root = NULL;
@@ -135,12 +120,10 @@ node *deleteNode(node *root, int key)
 
 // LevelOrder (Breadth First Search)
 
-void levelOrder(node *root)
-{
+void levelOrder(node *root) {
     queue<node *> q;
     q.push(root);
-    while (!q.empty())
-    {
+    while (!q.empty()) {
         root = q.front();
         cout << root->data << " ";
         q.pop();
@@ -151,8 +134,7 @@ void levelOrder(node *root)
     }
 }
 
-int main()
-{
+int main() {
     // Testing AVL Tree
     node *root = NULL;
     int i;
diff --git a/data_structure/binary_search_tree.cpp b/data_structure/binary_search_tree.cpp
index ea9df12d3..c3a74f385 100644
--- a/data_structure/binary_search_tree.cpp
+++ b/data_structure/binary_search_tree.cpp
@@ -1,15 +1,13 @@
 #include <iostream>
 using namespace std;
 
-struct node
-{
+struct node {
     int val;
     node *left;
     node *right;
 };
 
-struct queue
-{
+struct queue {
     node *t[100];
     int front;
     int rear;
@@ -21,107 +19,71 @@ void enqueue(node *n) { q.t[q.rear++] = n; }
 
 node *dequeue() { return (q.t[q.front++]); }
 
-void Insert(node *n, int x)
-{
-    if (x < n->val)
-    {
-        if (n->left == NULL)
-        {
+void Insert(node *n, int x) {
+    if (x < n->val) {
+        if (n->left == NULL) {
             node *temp = new node;
             temp->val = x;
             temp->left = NULL;
             temp->right = NULL;
             n->left = temp;
-        }
-        else
-        {
+        } else {
             Insert(n->left, x);
         }
-    }
-    else
-    {
-        if (n->right == NULL)
-        {
+    } else {
+        if (n->right == NULL) {
             node *temp = new node;
             temp->val = x;
             temp->left = NULL;
             temp->right = NULL;
             n->left = temp;
-        }
-        else
-        {
+        } else {
             Insert(n->right, x);
         }
     }
 }
 
-int findMaxInLeftST(node *n)
-{
-    while (n->right != NULL)
-    {
+int findMaxInLeftST(node *n) {
+    while (n->right != NULL) {
         n = n->right;
     }
     return n->val;
 }
 
-void Remove(node *p, node *n, int x)
-{
-    if (n->val == x)
-    {
-        if (n->right == NULL && n->left == NULL)
-        {
-            if (x < p->val)
-            {
+void Remove(node *p, node *n, int x) {
+    if (n->val == x) {
+        if (n->right == NULL && n->left == NULL) {
+            if (x < p->val) {
                 p->right = NULL;
-            }
-            else
-            {
+            } else {
                 p->left = NULL;
             }
-        }
-        else if (n->right == NULL)
-        {
-            if (x < p->val)
-            {
+        } else if (n->right == NULL) {
+            if (x < p->val) {
                 p->right = n->left;
-            }
-            else
-            {
+            } else {
                 p->left = n->left;
             }
-        }
-        else if (n->left == NULL)
-        {
-            if (x < p->val)
-            {
+        } else if (n->left == NULL) {
+            if (x < p->val) {
                 p->right = n->right;
-            }
-            else
-            {
+            } else {
                 p->left = n->right;
             }
-        }
-        else
-        {
+        } else {
             int y = findMaxInLeftST(n->left);
             n->val = y;
             Remove(n, n->right, y);
         }
-    }
-    else if (x < n->val)
-    {
+    } else if (x < n->val) {
         Remove(n, n->left, x);
-    }
-    else
-    {
+    } else {
         Remove(n, n->right, x);
     }
 }
 
-void BFT(node *n)
-{
-    if (n != NULL)
-    {
+void BFT(node *n) {
+    if (n != NULL) {
         cout << n->val << "  ";
         enqueue(n->left);
         enqueue(n->right);
@@ -129,38 +91,31 @@ void BFT(node *n)
     }
 }
 
-void Pre(node *n)
-{
-    if (n != NULL)
-    {
+void Pre(node *n) {
+    if (n != NULL) {
         cout << n->val << "  ";
         Pre(n->left);
         Pre(n->right);
     }
 }
 
-void In(node *n)
-{
-    if (n != NULL)
-    {
+void In(node *n) {
+    if (n != NULL) {
         In(n->left);
         cout << n->val << "  ";
         In(n->right);
     }
 }
 
-void Post(node *n)
-{
-    if (n != NULL)
-    {
+void Post(node *n) {
+    if (n != NULL) {
         Post(n->left);
         Post(n->right);
         cout << n->val << "  ";
     }
 }
 
-int main()
-{
+int main() {
     q.front = 0;
     q.rear = 0;
     int value;
@@ -171,8 +126,7 @@ int main()
     root->val = value;
     root->left = NULL;
     root->right = NULL;
-    do
-    {
+    do {
         cout << "\n1. Insert";
         cout << "\n2. Delete";
         cout << "\n3. Breadth First";
@@ -183,8 +137,7 @@ int main()
         cout << "\nEnter Your Choice : ";
         cin >> ch;
         int x;
-        switch (ch)
-        {
+        switch (ch) {
         case 1:
             cout << "\nEnter the value to be Inserted : ";
             cin >> x;
diff --git a/data_structure/binaryheap.cpp b/data_structure/binaryheap.cpp
index b2fc7d99c..a31d87674 100644
--- a/data_structure/binaryheap.cpp
+++ b/data_structure/binaryheap.cpp
@@ -7,8 +7,7 @@ using namespace std;
 void swap(int *x, int *y);
 
 // A class for Min Heap
-class MinHeap
-{
+class MinHeap {
     int *harr;      // pointer to array of elements in heap
     int capacity;   // maximum possible size of min heap
     int heap_size;  // Current number of elements in min heap
@@ -44,18 +43,15 @@ class MinHeap
 };
 
 // Constructor: Builds a heap from a given array a[] of given size
-MinHeap::MinHeap(int cap)
-{
+MinHeap::MinHeap(int cap) {
     heap_size = 0;
     capacity = cap;
     harr = new int[cap];
 }
 
 // Inserts a new key 'k'
-void MinHeap::insertKey(int k)
-{
-    if (heap_size == capacity)
-    {
+void MinHeap::insertKey(int k) {
+    if (heap_size == capacity) {
         cout << "\nOverflow: Could not insertKey\n";
         return;
     }
@@ -66,8 +62,7 @@ void MinHeap::insertKey(int k)
     harr[i] = k;
 
     // Fix the min heap property if it is violated
-    while (i != 0 && harr[parent(i)] > harr[i])
-    {
+    while (i != 0 && harr[parent(i)] > harr[i]) {
         swap(&harr[i], &harr[parent(i)]);
         i = parent(i);
     }
@@ -75,23 +70,19 @@ void MinHeap::insertKey(int k)
 
 // Decreases value of key at index 'i' to new_val.  It is assumed that
 // new_val is smaller than harr[i].
-void MinHeap::decreaseKey(int i, int new_val)
-{
+void MinHeap::decreaseKey(int i, int new_val) {
     harr[i] = new_val;
-    while (i != 0 && harr[parent(i)] > harr[i])
-    {
+    while (i != 0 && harr[parent(i)] > harr[i]) {
         swap(&harr[i], &harr[parent(i)]);
         i = parent(i);
     }
 }
 
 // Method to remove minimum element (or root) from min heap
-int MinHeap::extractMin()
-{
+int MinHeap::extractMin() {
     if (heap_size <= 0)
         return INT_MAX;
-    if (heap_size == 1)
-    {
+    if (heap_size == 1) {
         heap_size--;
         return harr[0];
     }
@@ -107,16 +98,14 @@ int MinHeap::extractMin()
 
 // This function deletes key at index i. It first reduced value to minus
 // infinite, then calls extractMin()
-void MinHeap::deleteKey(int i)
-{
+void MinHeap::deleteKey(int i) {
     decreaseKey(i, INT_MIN);
     extractMin();
 }
 
 // A recursive method to heapify a subtree with the root at given index
 // This method assumes that the subtrees are already heapified
-void MinHeap::MinHeapify(int i)
-{
+void MinHeap::MinHeapify(int i) {
     int l = left(i);
     int r = right(i);
     int smallest = i;
@@ -124,24 +113,21 @@ void MinHeap::MinHeapify(int i)
         smallest = l;
     if (r < heap_size && harr[r] < harr[smallest])
         smallest = r;
-    if (smallest != i)
-    {
+    if (smallest != i) {
         swap(&harr[i], &harr[smallest]);
         MinHeapify(smallest);
     }
 }
 
 // A utility function to swap two elements
-void swap(int *x, int *y)
-{
+void swap(int *x, int *y) {
     int temp = *x;
     *x = *y;
     *y = temp;
 }
 
 // Driver program to test above functions
-int main()
-{
+int main() {
     MinHeap h(11);
     h.insertKey(3);
     h.insertKey(2);
diff --git a/data_structure/circular_queue_using_linked_list.cpp b/data_structure/circular_queue_using_linked_list.cpp
index d87124448..b6a471044 100644
--- a/data_structure/circular_queue_using_linked_list.cpp
+++ b/data_structure/circular_queue_using_linked_list.cpp
@@ -1,24 +1,20 @@
 #include <iostream>
 using namespace std;
 
-struct node
-{
+struct node {
     int data;
     struct node *next;
 };
-class Queue
-{
+class Queue {
     node *front;
     node *rear;
 
  public:
-    Queue()
-    {
+    Queue() {
         front = NULL;
         rear = NULL;
     }
-    void createNode(int val)
-    {
+    void createNode(int val) {
         node *ptr;
         node *nn;
         nn = new node;
@@ -28,14 +24,10 @@ class Queue
         front = nn;
         rear = nn;
     }
-    void enqueue(int val)
-    {
-        if (front == NULL || rear == NULL)
-        {
+    void enqueue(int val) {
+        if (front == NULL || rear == NULL) {
             createNode(val);
-        }
-        else
-        {
+        } else {
             node *ptr;
             node *nn;
             ptr = front;
@@ -46,19 +38,16 @@ class Queue
             rear = nn;
         }
     }
-    void dequeue()
-    {
+    void dequeue() {
         node *n;
         n = front;
         front = front->next;
         delete (n);
     }
-    void traverse()
-    {
+    void traverse() {
         node *ptr;
         ptr = front;
-        do
-        {
+        do {
             cout << ptr->data << " ";
             ptr = ptr->next;
         } while (ptr != rear->next);
@@ -66,8 +55,7 @@ class Queue
         cout << endl;
     }
 };
-int main(void)
-{
+int main(void) {
     Queue q;
     q.enqueue(10);
     q.enqueue(20);
diff --git a/data_structure/cll/cll.cpp b/data_structure/cll/cll.cpp
index e9fcfc40b..42bc9067e 100644
--- a/data_structure/cll/cll.cpp
+++ b/data_structure/cll/cll.cpp
@@ -5,25 +5,22 @@
 using namespace std;
 
 /* Constructor */
-cll::cll()
-{
+cll::cll() {
     head = NULL;
     total = 0;
 }
 
-cll::~cll() { /* Desstructure, no need to fill */ }
+cll::~cll() { /* Desstructure, no need to fill */
+}
 
 /* Display a list. and total element */
-void cll::display()
-{
+void cll::display() {
     if (head == NULL)
         cout << "List is empty !" << endl;
-    else
-    {
+    else {
         cout << "CLL list: ";
         node *current = head;
-        for (int i = 0; i < total; i++)
-        {
+        for (int i = 0; i < total; i++) {
             cout << current->data << " -> ";
             current = current->next;
         }
@@ -33,22 +30,17 @@ void cll::display()
 }
 
 /* List insert a new value at head in list */
-void cll::insert_front(int new_data)
-{
+void cll::insert_front(int new_data) {
     node *newNode;
     newNode = new node;
     newNode->data = new_data;
     newNode->next = NULL;
-    if (head == NULL)
-    {
+    if (head == NULL) {
         head = newNode;
         head->next = head;
-    }
-    else
-    {
+    } else {
         node *current = head;
-        while (current->next != head)
-        {
+        while (current->next != head) {
             current = current->next;
         }
         newNode->next = head;
@@ -59,22 +51,17 @@ void cll::insert_front(int new_data)
 }
 
 /* List insert a new value at head in list */
-void cll::insert_tail(int new_data)
-{
+void cll::insert_tail(int new_data) {
     node *newNode;
     newNode = new node;
     newNode->data = new_data;
     newNode->next = NULL;
-    if (head == NULL)
-    {
+    if (head == NULL) {
         head = newNode;
         head->next = head;
-    }
-    else
-    {
+    } else {
         node *current = head;
-        while (current->next != head)
-        {
+        while (current->next != head) {
             current = current->next;
         }
         current->next = newNode;
@@ -88,18 +75,13 @@ int cll::get_size() { return total; }
 
 /* Return true if the requested item (sent in as an argument)
 is in the list, otherwise return false */
-bool cll::find_item(int item_to_find)
-{
-    if (head == NULL)
-    {
+bool cll::find_item(int item_to_find) {
+    if (head == NULL) {
         cout << "List is empty !" << endl;
         return false;
-    }
-    else
-    {
+    } else {
         node *current = head;
-        while (current->next != head)
-        {
+        while (current->next != head) {
             if (current->data == item_to_find)
                 return true;
             current = current->next;
@@ -113,17 +95,12 @@ int cll::operator*() { return head->data; }
 
 /* Overload the pre-increment operator.
    The iterator is advanced to the next node. */
-void cll::operator++()
-{
-    if (head == NULL)
-    {
+void cll::operator++() {
+    if (head == NULL) {
         cout << "List is empty !" << endl;
-    }
-    else
-    {
+    } else {
         node *current = head;
-        while (current->next != head)
-        {
+        while (current->next != head) {
             current = current->next;
         }
         current->next = head->next;
diff --git a/data_structure/cll/cll.h b/data_structure/cll/cll.h
index 89a9fe199..a1a9b4d92 100644
--- a/data_structure/cll/cll.h
+++ b/data_structure/cll/cll.h
@@ -9,14 +9,12 @@
 #ifndef CLL_H
 #define CLL_H
 /*The data structure is a linear linked list of integers */
-struct node
-{
+struct node {
     int data;
     node* next;
 };
 
-class cll
-{
+class cll {
  public:
     cll(); /* Construct without parameter */
     ~cll();
diff --git a/data_structure/cll/main_cll.cpp b/data_structure/cll/main_cll.cpp
index 3876f0393..0b6bfd3ed 100644
--- a/data_structure/cll/main_cll.cpp
+++ b/data_structure/cll/main_cll.cpp
@@ -1,8 +1,7 @@
 #include "cll.h"
 using namespace std;
 
-int main()
-{
+int main() {
     /* Test CLL */
     cout << "----------- Test construct -----------" << endl;
     cll list1;
diff --git a/data_structure/disjoint_set.cpp b/data_structure/disjoint_set.cpp
index 8d27b704f..dd70e4cea 100644
--- a/data_structure/disjoint_set.cpp
+++ b/data_structure/disjoint_set.cpp
@@ -7,20 +7,16 @@ using std::vector;
 
 vector<int> root, rnk;
 
-void CreateSet(int n)
-{
+void CreateSet(int n) {
     root = vector<int>(n + 1);
     rnk = vector<int>(n + 1, 1);
-    for (int i = 1; i <= n; ++i)
-    {
+    for (int i = 1; i <= n; ++i) {
         root[i] = i;
     }
 }
 
-int Find(int x)
-{
-    if (root[x] == x)
-    {
+int Find(int x) {
+    if (root[x] == x) {
         return x;
     }
     return root[x] = Find(root[x]);
@@ -28,50 +24,38 @@ int Find(int x)
 
 bool InSameUnion(int x, int y) { return Find(x) == Find(y); }
 
-void Union(int x, int y)
-{
+void Union(int x, int y) {
     int a = Find(x), b = Find(y);
-    if (a != b)
-    {
-        if (rnk[a] < rnk[b])
-        {
+    if (a != b) {
+        if (rnk[a] < rnk[b]) {
             root[a] = b;
-        }
-        else if (rnk[a] > rnk[b])
-        {
+        } else if (rnk[a] > rnk[b]) {
             root[b] = a;
-        }
-        else
-        {
+        } else {
             root[a] = b;
             ++rnk[b];
         }
     }
 }
 
-int main()
-{
+int main() {
     // tests CreateSet & Find
     int n = 100;
     CreateSet(n);
-    for (int i = 1; i <= 100; ++i)
-    {
-        if (root[i] != i)
-        {
+    for (int i = 1; i <= 100; ++i) {
+        if (root[i] != i) {
             cout << "Fail" << endl;
             break;
         }
     }
     // tests InSameUnion & Union
     cout << "1 and 2 are initially not in the same subset" << endl;
-    if (InSameUnion(1, 2))
-    {
+    if (InSameUnion(1, 2)) {
         cout << "Fail" << endl;
     }
     Union(1, 2);
     cout << "1 and 2 are now in the same subset" << endl;
-    if (!InSameUnion(1, 2))
-    {
+    if (!InSameUnion(1, 2)) {
         cout << "Fail" << endl;
     }
     return 0;
diff --git a/data_structure/doubly_linked_list.cpp b/data_structure/doubly_linked_list.cpp
index 4907c125d..30cc257d8 100644
--- a/data_structure/doubly_linked_list.cpp
+++ b/data_structure/doubly_linked_list.cpp
@@ -2,15 +2,13 @@
 #include <cstdlib>
 #include <iostream>
 
-struct node
-{
+struct node {
     int val;
     node *prev;
     node *next;
 } * start;
 
-class double_linked_list
-{
+class double_linked_list {
  public:
     double_linked_list() { start = NULL; }
     void insert(int x);
@@ -20,13 +18,10 @@ class double_linked_list
     void reverseShow();
 };
 
-void double_linked_list::insert(int x)
-{
+void double_linked_list::insert(int x) {
     node *t = start;
-    if (start != NULL)
-    {
-        while (t->next != NULL)
-        {
+    if (start != NULL) {
+        while (t->next != NULL) {
             t = t->next;
         }
         node *n = new node;
@@ -34,9 +29,7 @@ void double_linked_list::insert(int x)
         n->prev = t;
         n->val = x;
         n->next = NULL;
-    }
-    else
-    {
+    } else {
         node *n = new node;
         n->val = x;
         n->prev = NULL;
@@ -45,91 +38,69 @@ void double_linked_list::insert(int x)
     }
 }
 
-void double_linked_list::remove(int x)
-{
+void double_linked_list::remove(int x) {
     node *t = start;
-    while (t != NULL && t->val != x)
-    {
+    while (t != NULL && t->val != x) {
         t = t->next;
     }
-    if (t == NULL)
-    {
+    if (t == NULL) {
         return;
     }
-    if (t->prev == NULL)
-    {
-        if (t->next == NULL)
-        {
+    if (t->prev == NULL) {
+        if (t->next == NULL) {
             start = NULL;
-        }
-        else
-        {
+        } else {
             start = t->next;
             start->prev = NULL;
         }
-    }
-    else if (t->next == NULL)
-    {
+    } else if (t->next == NULL) {
         t->prev->next = NULL;
-    }
-    else
-    {
+    } else {
         t->prev->next = t->next;
         t->next->prev = t->prev;
     }
     delete t;
 }
 
-void double_linked_list::search(int x)
-{
+void double_linked_list::search(int x) {
     node *t = start;
     int found = 0;
-    while (t != NULL)
-    {
-        if (t->val == x)
-        {
+    while (t != NULL) {
+        if (t->val == x) {
             std::cout << "\nFound";
             found = 1;
             break;
         }
         t = t->next;
     }
-    if (found == 0)
-    {
+    if (found == 0) {
         std::cout << "\nNot Found";
     }
 }
 
-void double_linked_list::show()
-{
+void double_linked_list::show() {
     node *t = start;
-    while (t != NULL)
-    {
+    while (t != NULL) {
         std::cout << t->val << "\t";
         t = t->next;
     }
 }
 
-void double_linked_list::reverseShow()
-{
+void double_linked_list::reverseShow() {
     node *t = start;
-    while (t != NULL && t->next != NULL)
-    {
+    while (t != NULL && t->next != NULL) {
         t = t->next;
     }
-    while (t != NULL)
-    {
+    while (t != NULL) {
         std::cout << t->val << "\t";
         t = t->prev;
     }
 }
 
-int main()
-{
+int main() {
     int choice, x;
     double_linked_list ob;
-    do
-    {
+    do {
         std::cout << "\n1. Insert";
         std::cout << "\n2. Delete";
         std::cout << "\n3. Search";
@@ -137,8 +108,7 @@ int main()
         std::cout << "\n5. Reverse print";
         std::cout << "\n\nEnter you choice : ";
         std::cin >> choice;
-        switch (choice)
-        {
+        switch (choice) {
         case 1:
             std::cout << "\nEnter the element to be inserted : ";
             std::cin >> x;
diff --git a/data_structure/linked_list.cpp b/data_structure/linked_list.cpp
index f639bb16c..8eb6e586d 100644
--- a/data_structure/linked_list.cpp
+++ b/data_structure/linked_list.cpp
@@ -1,42 +1,32 @@
 #include <iostream>
 
-struct node
-{
+struct node {
     int val;
     node *next;
 };
 
 node *start;
 
-void insert(int x)
-{
+void insert(int x) {
     node *t = start;
     node *n = new node;
     n->val = x;
     n->next = NULL;
-    if (start != NULL)
-    {
-        while (t->next != NULL)
-        {
+    if (start != NULL) {
+        while (t->next != NULL) {
             t = t->next;
         }
         t->next = n;
-    }
-    else
-    {
+    } else {
         start = n;
     }
 }
 
-void remove(int x)
-{
-    if (start == NULL)
-    {
+void remove(int x) {
+    if (start == NULL) {
         std::cout << "\nLinked List is empty\n";
         return;
-    }
-    else if (start->val == x)
-    {
+    } else if (start->val == x) {
         node *temp = start;
         start = start->next;
         delete temp;
@@ -45,14 +35,12 @@ void remove(int x)
 
     node *temp = start, *parent = start;
 
-    while (temp != NULL && temp->val != x)
-    {
+    while (temp != NULL && temp->val != x) {
         parent = temp;
         temp = temp->next;
     }
 
-    if (temp == NULL)
-    {
+    if (temp == NULL) {
         std::cout << std::endl << x << " not found in list\n";
         return;
     }
@@ -61,44 +49,35 @@ void remove(int x)
     delete temp;
 }
 
-void search(int x)
-{
+void search(int x) {
     node *t = start;
     int found = 0;
-    while (t != NULL)
-    {
-        if (t->val == x)
-        {
+    while (t != NULL) {
+        if (t->val == x) {
             std::cout << "\nFound";
             found = 1;
             break;
         }
         t = t->next;
     }
-    if (found == 0)
-    {
+    if (found == 0) {
         std::cout << "\nNot Found";
     }
 }
 
-void show()
-{
+void show() {
     node *t = start;
-    while (t != NULL)
-    {
+    while (t != NULL) {
         std::cout << t->val << "\t";
         t = t->next;
     }
 }
 
-void reverse()
-{
+void reverse() {
     node *first = start;
-    if (first != NULL)
-    {
+    if (first != NULL) {
         node *second = first->next;
-        while (second != NULL)
-        {
+        while (second != NULL) {
             node *tem = second->next;
             second->next = first;
             first = second;
@@ -106,18 +85,14 @@ void reverse()
         }
         start->next = NULL;
         start = first;
-    }
-    else
-    {
+    } else {
         std::cout << "\nEmpty list";
     }
 }
 
-int main()
-{
+int main() {
     int choice, x;
-    do
-    {
+    do {
         std::cout << "\n1. Insert";
         std::cout << "\n2. Delete";
         std::cout << "\n3. Search";
@@ -126,8 +101,7 @@ int main()
         std::cout << "\n0. Exit";
         std::cout << "\n\nEnter you choice : ";
         std::cin >> choice;
-        switch (choice)
-        {
+        switch (choice) {
         case 1:
             std::cout << "\nEnter the element to be inserted : ";
             std::cin >> x;
diff --git a/data_structure/linkedlist_implentation_usingarray.cpp b/data_structure/linkedlist_implentation_usingarray.cpp
index 168124f00..a078bef16 100644
--- a/data_structure/linkedlist_implentation_usingarray.cpp
+++ b/data_structure/linkedlist_implentation_usingarray.cpp
@@ -7,18 +7,15 @@
 
 #include <iostream>
 using namespace std;
-struct Node
-{
+struct Node {
     int data;
     int next;
 };
 Node AvailArray[100];  // array that will act as nodes of a linked list.
 int head = -1;
 int avail = 0;
-void initialise_list()
-{
-    for (int i = 0; i <= 98; i++)
-    {
+void initialise_list() {
+    for (int i = 0; i <= 98; i++) {
         AvailArray[i].next = i + 1;
     }
     AvailArray[99].next = -1;  // indicating the end of the linked list.
@@ -50,12 +47,10 @@ void insertAtTheBeginning(int data)  // The function will insert the given data
     head = newNode;
 }
 
-void insertAtTheEnd(int data)
-{
+void insertAtTheEnd(int data) {
     int newNode = getnode();
     int temp = head;
-    while (AvailArray[temp].next != -1)
-    {
+    while (AvailArray[temp].next != -1) {
         temp = AvailArray[temp].next;
     }
     // temp is now pointing to the end node.
@@ -64,11 +59,9 @@ void insertAtTheEnd(int data)
     AvailArray[temp].next = newNode;
 }
 
-void display()
-{
+void display() {
     int temp = head;
-    while (temp != -1)
-    {
+    while (temp != -1) {
         cout << AvailArray[temp].data << "->";
         temp = AvailArray[temp].next;
     }
@@ -76,20 +69,17 @@ void display()
     ;
 }
 
-int main()
-{
+int main() {
     initialise_list();
     int x, y, z;
-    for (;;)
-    {
+    for (;;) {
         cout << "1. Insert At The Beginning" << endl;
         cout << "2. Insert At The End" << endl;
         cout << "3. Display" << endl;
         cout << "4.Exit" << endl;
         cout << "Enter Your choice" << endl;
         cin >> z;
-        switch (z)
-        {
+        switch (z) {
         case 1:
             cout << "Enter the number you want to enter" << endl;
             cin >> x;
diff --git a/data_structure/list_array.cpp b/data_structure/list_array.cpp
index f572b77b4..c796ffef9 100644
--- a/data_structure/list_array.cpp
+++ b/data_structure/list_array.cpp
@@ -1,16 +1,13 @@
 #include <iostream>
 using namespace std;
 
-struct list
-{
+struct list {
     int data[50];
     int top = 0;
     bool isSorted = false;
 
-    int BinarySearch(int *array, int first, int last, int x)
-    {
-        if (last < first)
-        {
+    int BinarySearch(int *array, int first, int last, int x) {
+        if (last < first) {
             return -1;
         }
         int mid = (first + last) / 2;
@@ -22,12 +19,9 @@ struct list
             return (BinarySearch(array, mid + 1, last, x));
     }
 
-    int LinarSearch(int *array, int x)
-    {
-        for (int i = 0; i < top; i++)
-        {
-            if (array[i] == x)
-            {
+    int LinarSearch(int *array, int x) {
+        for (int i = 0; i < top; i++) {
+            if (array[i] == x) {
                 return i;
             }
         }
@@ -35,41 +29,31 @@ struct list
         return -1;
     }
 
-    int Search(int x)
-    {
+    int Search(int x) {
         int pos = -1;
 
-        if (isSorted)
-        {
+        if (isSorted) {
             pos = BinarySearch(data, 0, top - 1, x);
         }
 
-        else
-        {
+        else {
             pos = LinarSearch(data, x);
         }
 
-        if (pos != -1)
-        {
+        if (pos != -1) {
             cout << "\nElement found at position : " << pos;
-        }
-        else
-        {
+        } else {
             cout << "\nElement not found";
         }
         return pos;
     }
 
-    void Sort()
-    {
+    void Sort() {
         int i, j, pos;
-        for (i = 0; i < top; i++)
-        {
+        for (i = 0; i < top; i++) {
             int min = data[i];
-            for (j = i + 1; j < top; j++)
-            {
-                if (data[j] < min)
-                {
+            for (j = i + 1; j < top; j++) {
+                if (data[j] < min) {
                     pos = j;
                     min = data[pos];
                 }
@@ -82,40 +66,30 @@ struct list
         isSorted = true;
     }
 
-    void insert(int x)
-    {
-        if (!isSorted)
-        {
-            if (top == 49)
-            {
+    void insert(int x) {
+        if (!isSorted) {
+            if (top == 49) {
                 cout << "\nOverflow";
-            }
-            else
-            {
+            } else {
                 data[top] = x;
                 top++;
             }
         }
 
-        else
-        {
+        else {
             int pos = 0;
 
-            for (int i = 0; i < top - 1; i++)
-            {
-                if (data[i] <= x && x <= data[i + 1])
-                {
+            for (int i = 0; i < top - 1; i++) {
+                if (data[i] <= x && x <= data[i + 1]) {
                     pos = i + 1;
                     break;
                 }
             }
-            if (pos == 0)
-            {
+            if (pos == 0) {
                 pos = top - 1;
             }
 
-            for (int i = top; i > pos; i--)
-            {
+            for (int i = top; i > pos; i--) {
                 data[i] = data[i - 1];
             }
             top++;
@@ -123,33 +97,27 @@ struct list
         }
     }
 
-    void Remove(int x)
-    {
+    void Remove(int x) {
         int pos = Search(x);
         cout << "\n" << data[pos] << " deleted";
-        for (int i = pos; i < top; i++)
-        {
+        for (int i = pos; i < top; i++) {
             data[i] = data[i + 1];
         }
         top--;
     }
 
-    void Show()
-    {
-        for (int i = 0; i < top; i++)
-        {
+    void Show() {
+        for (int i = 0; i < top; i++) {
             cout << data[i] << "\t";
         }
     }
 };
 
-int main()
-{
+int main() {
     list L;
     int choice;
     int x;
-    do
-    {
+    do {
         cout << "\n1.Insert";
         cout << "\n2.Delete";
         cout << "\n3.Search";
@@ -157,8 +125,7 @@ int main()
         cout << "\n5.Print";
         cout << "\n\nEnter Your Choice : ";
         cin >> choice;
-        switch (choice)
-        {
+        switch (choice) {
         case 1:
             cout << "\nEnter the element to be inserted : ";
             cin >> x;
diff --git a/data_structure/morrisinorder.cpp b/data_structure/morrisinorder.cpp
index 58f267907..f1f9e068c 100644
--- a/data_structure/morrisinorder.cpp
+++ b/data_structure/morrisinorder.cpp
@@ -7,39 +7,32 @@
 
 using namespace std;
 
-struct Btree
-{
+struct Btree {
     int data;
     struct Btree *left;   // Pointer to left subtree
     struct Btree *right;  // Pointer to right subtree
 };
 
-void insert(Btree **root, int d)
-{
+void insert(Btree **root, int d) {
     Btree *nn = new Btree();  // Creating new node
     nn->data = d;
     nn->left = NULL;
     nn->right = NULL;
-    if (*root == NULL)
-    {
+    if (*root == NULL) {
         *root = nn;
         return;
-    }
-    else
-    {
+    } else {
         queue<Btree *> q;
         // Adding root node to queue
         q.push(*root);
-        while (!q.empty())
-        {
+        while (!q.empty()) {
             Btree *node = q.front();
             // Removing parent node from queue
             q.pop();
             if (node->left)
                 // Adding left child of removed node to queue
                 q.push(node->left);
-            else
-            {
+            else {
                 // Adding new node if no left child is present
                 node->left = nn;
                 return;
@@ -47,8 +40,7 @@ void insert(Btree **root, int d)
             if (node->right)
                 // Adding right child of removed node to queue
                 q.push(node->right);
-            else
-            {
+            else {
                 // Adding new node if no right child is present
                 node->right = nn;
                 return;
@@ -57,36 +49,29 @@ void insert(Btree **root, int d)
     }
 }
 
-void morrisInorder(Btree *root)
-{
+void morrisInorder(Btree *root) {
     Btree *curr = root;
     Btree *temp;
-    while (curr)
-    {
-        if (curr->left == NULL)
-        {
+    while (curr) {
+        if (curr->left == NULL) {
             cout << curr->data << " ";
             // If left of current node is NULL then curr is shifted to right
             curr = curr->right;
-        }
-        else
-        {
+        } else {
             // Left of current node is stored in temp
             temp = curr->left;
             // Moving to extreme right of temp
             while (temp->right && temp->right != curr) temp = temp->right;
             // If extreme right is null it is made to point to currrent node
             // (will be used for backtracking)
-            if (temp->right == NULL)
-            {
+            if (temp->right == NULL) {
                 temp->right = curr;
                 // current node is made to point its left subtree
                 curr = curr->left;
             }
             // If extreme right already points to currrent node it it set to
             // null
-            else if (temp->right == curr)
-            {
+            else if (temp->right == curr) {
                 cout << curr->data << " ";
                 temp->right = NULL;
                 // current node is made to point its right subtree
@@ -96,8 +81,7 @@ void morrisInorder(Btree *root)
     }
 }
 
-int main()
-{
+int main() {
     // Testing morrisInorder funtion
     Btree *root = NULL;
     int i;
diff --git a/data_structure/queue/queue.cpp b/data_structure/queue/queue.cpp
index e8ff8966c..a7055bb14 100644
--- a/data_structure/queue/queue.cpp
+++ b/data_structure/queue/queue.cpp
@@ -6,8 +6,7 @@ using namespace std;
 
 /* Default constructor*/
 template <class Kind>
-queue<Kind>::queue()
-{
+queue<Kind>::queue() {
     queueFront = NULL;
     queueRear = NULL;
     size = 0;
@@ -15,18 +14,14 @@ queue<Kind>::queue()
 
 /* Destructor */
 template <class Kind>
-queue<Kind>::~queue()
-{
-}
+queue<Kind>::~queue() {}
 
 /* Display for testing */
 template <class Kind>
-void queue<Kind>::display()
-{
+void queue<Kind>::display() {
     node<Kind> *current = queueFront;
     cout << "Front --> ";
-    while (current != NULL)
-    {
+    while (current != NULL) {
         cout << current->data << "    ";
         current = current->next;
     }
@@ -36,33 +31,27 @@ void queue<Kind>::display()
 
 /* Determine whether the queue is empty */
 template <class Kind>
-bool queue<Kind>::isEmptyQueue()
-{
+bool queue<Kind>::isEmptyQueue() {
     return (queueFront == NULL);
 }
 
 /* Clear queue */
 template <class Kind>
-void queue<Kind>::clear()
-{
+void queue<Kind>::clear() {
     queueFront = NULL;
 }
 
 /* Add new item to the queue */
 template <class Kind>
-void queue<Kind>::enQueue(Kind item)
-{
+void queue<Kind>::enQueue(Kind item) {
     node<Kind> *newNode;
     newNode = new node<Kind>;
     newNode->data = item;
     newNode->next = NULL;
-    if (queueFront == NULL)
-    {
+    if (queueFront == NULL) {
         queueFront = newNode;
         queueRear = newNode;
-    }
-    else
-    {
+    } else {
         queueRear->next = newNode;
         queueRear = queueRear->next;
     }
@@ -71,26 +60,21 @@ void queue<Kind>::enQueue(Kind item)
 
 /* Return the top element of the queue */
 template <class Kind>
-Kind queue<Kind>::front()
-{
+Kind queue<Kind>::front() {
     assert(queueFront != NULL);
     return queueFront->data;
 }
 
 /* Remove the element of the queue */
 template <class Kind>
-void queue<Kind>::deQueue()
-{
+void queue<Kind>::deQueue() {
     node<Kind> *temp;
-    if (!isEmptyQueue())
-    {
+    if (!isEmptyQueue()) {
         temp = queueFront;
         queueFront = queueFront->next;
         delete temp;
         size--;
-    }
-    else
-    {
+    } else {
         cout << "Queue is empty !" << endl;
     }
 }
diff --git a/data_structure/queue/queue.h b/data_structure/queue/queue.h
index 7e9c44559..d1305fc81 100644
--- a/data_structure/queue/queue.h
+++ b/data_structure/queue/queue.h
@@ -4,16 +4,14 @@
 
 /* Definition of the node */
 template <class Kind>
-struct node
-{
+struct node {
     Kind data;
     node<Kind> *next;
 };
 
 /* Definition of the queue class */
 template <class Kind>
-class queue
-{
+class queue {
  public:
     void display();          /* Show queue */
     queue();                 /* Default constructor*/
diff --git a/data_structure/queue/test_queue.cpp b/data_structure/queue/test_queue.cpp
index d9308adcb..7f0923f78 100644
--- a/data_structure/queue/test_queue.cpp
+++ b/data_structure/queue/test_queue.cpp
@@ -5,8 +5,7 @@
 
 using namespace std;
 
-int main()
-{
+int main() {
     queue<string> q;
     cout << "---------------------- Test construct ----------------------"
          << endl;
diff --git a/data_structure/queue_using_array.cpp b/data_structure/queue_using_array.cpp
index c7fbf1ef7..a887c99fc 100644
--- a/data_structure/queue_using_array.cpp
+++ b/data_structure/queue_using_array.cpp
@@ -10,15 +10,13 @@
 
 #define MAXSIZE 10
 
-class Queue_Array
-{
+class Queue_Array {
     int front;
     int rear;
     int size;
 
  public:
-    Queue_Array()
-    {
+    Queue_Array() {
         front = -1;
         rear = -1;
         size = MAXSIZE;
@@ -29,59 +27,42 @@ class Queue_Array
     void display();
 };
 
-void Queue_Array::enqueue(int ele)
-{
-    if (rear == size - 1)
-    {
+void Queue_Array::enqueue(int ele) {
+    if (rear == size - 1) {
         std::cout << "\nStack is full";
-    }
-    else if (front == -1 && rear == -1)
-    {
+    } else if (front == -1 && rear == -1) {
         front = rear = 0;
         arr[rear] = ele;
-    }
-    else if (rear < size)
-    {
+    } else if (rear < size) {
         rear++;
         arr[rear] = ele;
     }
 }
 
-int Queue_Array::dequeue()
-{
+int Queue_Array::dequeue() {
     int d;
-    if (front == -1)
-    {
+    if (front == -1) {
         std::cout << "\nstack is empty ";
         return 0;
-    }
-    else if (front == rear)
-    {
+    } else if (front == rear) {
         d = arr[front];
         front = rear = -1;
-    }
-    else
-    {
+    } else {
         d = arr[front++];
     }
 
     return d;
 }
 
-void Queue_Array::display()
-{
-    if (front == -1)
-    {
+void Queue_Array::display() {
+    if (front == -1) {
         std::cout << "\nStack is empty";
-    }
-    else
-    {
+    } else {
         for (int i = front; i <= rear; i++) std::cout << arr[i] << " ";
     }
 }
 
-int main()
-{
+int main() {
     int op, data;
 
     Queue_Array ob;
@@ -90,31 +71,21 @@ int main()
     std::cout << "\n2. dequeue(Deletion)";
     std::cout << "\n3. Display";
     std::cout << "\n4. Exit";
-    while (1)
-    {
+    while (1) {
         std::cout << "\nEnter your choice ";
         std::cin >> op;
-        if (op == 1)
-        {
+        if (op == 1) {
             std::cout << "Enter data  ";
             std::cin >> data;
             ob.enqueue(data);
-        }
-        else if (op == 2)
-        {
+        } else if (op == 2) {
             data = ob.dequeue();
             std::cout << "\ndequeue element is:\t" << data;
-        }
-        else if (op == 3)
-        {
+        } else if (op == 3) {
             ob.display();
-        }
-        else if (op == 4)
-        {
+        } else if (op == 4) {
             exit(0);
-        }
-        else
-        {
+        } else {
             std::cout << "\nWrong choice ";
         }
     }
diff --git a/data_structure/queue_using_array2.cpp b/data_structure/queue_using_array2.cpp
index 7e1ada725..13f7d8e17 100644
--- a/data_structure/queue_using_array2.cpp
+++ b/data_structure/queue_using_array2.cpp
@@ -5,30 +5,22 @@ int queue[10];
 int front = 0;
 int rear = 0;
 
-void Enque(int x)
-{
-    if (rear == 10)
-    {
+void Enque(int x) {
+    if (rear == 10) {
         cout << "\nOverflow";
-    }
-    else
-    {
+    } else {
         queue[rear++] = x;
     }
 }
 
-void Deque()
-{
-    if (front == rear)
-    {
+void Deque() {
+    if (front == rear) {
         cout << "\nUnderflow";
     }
 
-    else
-    {
+    else {
         cout << "\n" << queue[front++] << " deleted";
-        for (int i = front; i < rear; i++)
-        {
+        for (int i = front; i < rear; i++) {
             queue[i - front] = queue[i];
         }
         rear = rear - front;
@@ -36,36 +28,27 @@ void Deque()
     }
 }
 
-void show()
-{
-    for (int i = front; i < rear; i++)
-    {
+void show() {
+    for (int i = front; i < rear; i++) {
         cout << queue[i] << "\t";
     }
 }
 
-int main()
-{
+int main() {
     int ch, x;
-    do
-    {
+    do {
         cout << "\n1. Enque";
         cout << "\n2. Deque";
         cout << "\n3. Print";
         cout << "\nEnter Your Choice : ";
         cin >> ch;
-        if (ch == 1)
-        {
+        if (ch == 1) {
             cout << "\nInsert : ";
             cin >> x;
             Enque(x);
-        }
-        else if (ch == 2)
-        {
+        } else if (ch == 2) {
             Deque();
-        }
-        else if (ch == 3)
-        {
+        } else if (ch == 3) {
             show();
         }
     } while (ch != 0);
diff --git a/data_structure/queue_using_linked_list.cpp b/data_structure/queue_using_linked_list.cpp
index 9ddbdaa42..7b44d240c 100644
--- a/data_structure/queue_using_linked_list.cpp
+++ b/data_structure/queue_using_linked_list.cpp
@@ -1,18 +1,15 @@
 #include <iostream>
 using namespace std;
 
-struct node
-{
+struct node {
     int val;
     node *next;
 };
 
 node *front, *rear;
 
-void Enque(int x)
-{
-    if (rear == NULL)
-    {
+void Enque(int x) {
+    if (rear == NULL) {
         node *n = new node;
         n->val = x;
         n->next = NULL;
@@ -20,8 +17,7 @@ void Enque(int x)
         front = n;
     }
 
-    else
-    {
+    else {
         node *n = new node;
         n->val = x;
         n->next = NULL;
@@ -30,14 +26,10 @@ void Enque(int x)
     }
 }
 
-void Deque()
-{
-    if (rear == NULL && front == NULL)
-    {
+void Deque() {
+    if (rear == NULL && front == NULL) {
         cout << "\nUnderflow";
-    }
-    else
-    {
+    } else {
         node *t = front;
         cout << "\n" << t->val << " deleted";
         front = front->next;
@@ -47,38 +39,29 @@ void Deque()
     }
 }
 
-void show()
-{
+void show() {
     node *t = front;
-    while (t != NULL)
-    {
+    while (t != NULL) {
         cout << t->val << "\t";
         t = t->next;
     }
 }
 
-int main()
-{
+int main() {
     int ch, x;
-    do
-    {
+    do {
         cout << "\n1. Enque";
         cout << "\n2. Deque";
         cout << "\n3. Print";
         cout << "\nEnter Your Choice : ";
         cin >> ch;
-        if (ch == 1)
-        {
+        if (ch == 1) {
             cout << "\nInsert : ";
             cin >> x;
             Enque(x);
-        }
-        else if (ch == 2)
-        {
+        } else if (ch == 2) {
             Deque();
-        }
-        else if (ch == 3)
-        {
+        } else if (ch == 3) {
             show();
         }
     } while (ch != 0);
diff --git a/data_structure/queue_using_linkedlist.cpp b/data_structure/queue_using_linkedlist.cpp
index 21ff0cfcf..f1bf18123 100644
--- a/data_structure/queue_using_linkedlist.cpp
+++ b/data_structure/queue_using_linkedlist.cpp
@@ -3,13 +3,11 @@
 */
 #include <iostream>
 
-struct linkedlist
-{
+struct linkedlist {
     int data;
     linkedlist *next;
 };
-class stack_linkedList
-{
+class stack_linkedList {
  public:
     linkedlist *front;
     linkedlist *rear;
@@ -19,28 +17,24 @@ class stack_linkedList
     int dequeue();
     void display();
 };
-void stack_linkedList::enqueue(int ele)
-{
+void stack_linkedList::enqueue(int ele) {
     linkedlist *temp = new linkedlist();
     temp->data = ele;
     temp->next = NULL;
 
     if (front == NULL)
         front = rear = temp;
-    else
-    {
+    else {
         rear->next = temp;
         rear = temp;
     }
 }
-int stack_linkedList::dequeue()
-{
+int stack_linkedList::dequeue() {
     linkedlist *temp;
     int ele;
     if (front == NULL)
         std::cout << "\nStack is empty";
-    else
-    {
+    else {
         temp = front;
         ele = temp->data;
         if (front == rear)  // if length of queue is 1;
@@ -50,25 +44,21 @@ int stack_linkedList::dequeue()
     }
     return ele;
 }
-void stack_linkedList::display()
-{
+void stack_linkedList::display() {
     if (front == NULL)
         std::cout << "\nStack is empty";
 
-    else
-    {
+    else {
         linkedlist *temp;
         temp = front;
-        while (temp != NULL)
-        {
+        while (temp != NULL) {
             std::cout << temp->data << " ";
             temp = temp->next;
         }
     }
 }
 
-int main()
-{
+int main() {
     int op, data;
     stack_linkedList ob;
     std::cout << "\n1. enqueue(Insertion) ";
@@ -76,17 +66,14 @@ int main()
     std::cout << "\n3. Display";
     std::cout << "\n4. Exit";
 
-    while (1)
-    {
+    while (1) {
         std::cout << "\nEnter your choice ";
         std::cin >> op;
-        if (op == 1)
-        {
+        if (op == 1) {
             std::cout << "Enter data ";
             std::cin >> data;
             ob.enqueue(data);
-        }
-        else if (op == 2)
+        } else if (op == 2)
             data = ob.dequeue();
         else if (op == 3)
             ob.display();
diff --git a/data_structure/stack_using_array.cpp b/data_structure/stack_using_array.cpp
index dd0709ff2..5dd7ac98e 100644
--- a/data_structure/stack_using_array.cpp
+++ b/data_structure/stack_using_array.cpp
@@ -4,69 +4,50 @@ using namespace std;
 int *stack;
 int top = 0, size;
 
-void push(int x)
-{
-    if (top == size)
-    {
+void push(int x) {
+    if (top == size) {
         cout << "\nOverflow";
-    }
-    else
-    {
+    } else {
         stack[top++] = x;
     }
 }
 
-void pop()
-{
-    if (top == 0)
-    {
+void pop() {
+    if (top == 0) {
         cout << "\nUnderflow";
-    }
-    else
-    {
+    } else {
         cout << "\n" << stack[--top] << " deleted";
     }
 }
 
-void show()
-{
-    for (int i = 0; i < top; i++)
-    {
+void show() {
+    for (int i = 0; i < top; i++) {
         cout << stack[i] << "\n";
     }
 }
 
 void topmost() { cout << "\nTopmost element: " << stack[top - 1]; }
-int main()
-{
+int main() {
     cout << "\nEnter Size of stack : ";
     cin >> size;
     stack = new int[size];
     int ch, x;
-    do
-    {
+    do {
         cout << "\n1. Push";
         cout << "\n2. Pop";
         cout << "\n3. Print";
         cout << "\n4. Print topmost element:";
         cout << "\nEnter Your Choice : ";
         cin >> ch;
-        if (ch == 1)
-        {
+        if (ch == 1) {
             cout << "\nInsert : ";
             cin >> x;
             push(x);
-        }
-        else if (ch == 2)
-        {
+        } else if (ch == 2) {
             pop();
-        }
-        else if (ch == 3)
-        {
+        } else if (ch == 3) {
             show();
-        }
-        else if (ch == 4)
-        {
+        } else if (ch == 4) {
             topmost();
         }
     } while (ch != 0);
diff --git a/data_structure/stack_using_linked_list.cpp b/data_structure/stack_using_linked_list.cpp
index 89a15fe39..ae53fe95a 100644
--- a/data_structure/stack_using_linked_list.cpp
+++ b/data_structure/stack_using_linked_list.cpp
@@ -1,30 +1,24 @@
 #include <iostream>
 using namespace std;
 
-struct node
-{
+struct node {
     int val;
     node *next;
 };
 
 node *top;
 
-void push(int x)
-{
+void push(int x) {
     node *n = new node;
     n->val = x;
     n->next = top;
     top = n;
 }
 
-void pop()
-{
-    if (top == NULL)
-    {
+void pop() {
+    if (top == NULL) {
         cout << "\nUnderflow";
-    }
-    else
-    {
+    } else {
         node *t = top;
         cout << "\n" << t->val << " deleted";
         top = top->next;
@@ -32,38 +26,29 @@ void pop()
     }
 }
 
-void show()
-{
+void show() {
     node *t = top;
-    while (t != NULL)
-    {
+    while (t != NULL) {
         cout << t->val << "\n";
         t = t->next;
     }
 }
 
-int main()
-{
+int main() {
     int ch, x;
-    do
-    {
+    do {
         cout << "\n1. Push";
         cout << "\n2. Pop";
         cout << "\n3. Print";
         cout << "\nEnter Your Choice : ";
         cin >> ch;
-        if (ch == 1)
-        {
+        if (ch == 1) {
             cout << "\nInsert : ";
             cin >> x;
             push(x);
-        }
-        else if (ch == 2)
-        {
+        } else if (ch == 2) {
             pop();
-        }
-        else if (ch == 3)
-        {
+        } else if (ch == 3) {
             show();
         }
     } while (ch != 0);
diff --git a/data_structure/stk/main.cpp b/data_structure/stk/main.cpp
index ceac2ac8a..44b7984e0 100644
--- a/data_structure/stk/main.cpp
+++ b/data_structure/stk/main.cpp
@@ -19,8 +19,7 @@
 
 using namespace std;
 
-int main(int argc, char* argv[])
-{
+int main(int argc, char* argv[]) {
     double GPA;
     double highestGPA;
     string name;
@@ -35,24 +34,19 @@ int main(int argc, char* argv[])
     infile >> GPA >> name;
     highestGPA = GPA;
 
-    while (infile)
-    {
-        if (GPA > highestGPA)
-        {
+    while (infile) {
+        if (GPA > highestGPA) {
             stk.clear();
             stk.push(name);
             highestGPA = GPA;
-        }
-        else if (GPA == highestGPA)
-        {
+        } else if (GPA == highestGPA) {
             stk.push(name);
         }
         infile >> GPA >> name;
     }
     cout << "Highest GPA: " << highestGPA << endl;
     cout << "Students the highest GPA are: " << endl;
-    while (!stk.isEmptyStack())
-    {
+    while (!stk.isEmptyStack()) {
         cout << stk.top() << endl;
         stk.pop();
     }
diff --git a/data_structure/stk/stack.cpp b/data_structure/stk/stack.cpp
index 9f92efbd5..bfa8a353e 100644
--- a/data_structure/stk/stack.cpp
+++ b/data_structure/stk/stack.cpp
@@ -6,26 +6,21 @@ using namespace std;
 
 /* Default constructor*/
 template <class Type>
-stack<Type>::stack()
-{
+stack<Type>::stack() {
     stackTop = NULL;
     size = 0;
 }
 
 /* Destructor */
 template <class Type>
-stack<Type>::~stack()
-{
-}
+stack<Type>::~stack() {}
 
 /* Display for testing */
 template <class Type>
-void stack<Type>::display()
-{
+void stack<Type>::display() {
     node<Type> *current = stackTop;
     cout << "Top --> ";
-    while (current != NULL)
-    {
+    while (current != NULL) {
         cout << current->data << "  ";
         current = current->next;
     }
@@ -35,22 +30,19 @@ void stack<Type>::display()
 
 /* Determine whether the stack is empty */
 template <class Type>
-bool stack<Type>::isEmptyStack()
-{
+bool stack<Type>::isEmptyStack() {
     return (stackTop == NULL);
 }
 
 /* Clear stack */
 template <class Type>
-void stack<Type>::clear()
-{
+void stack<Type>::clear() {
     stackTop = NULL;
 }
 
 /* Add new item to the stack */
 template <class Type>
-void stack<Type>::push(Type item)
-{
+void stack<Type>::push(Type item) {
     node<Type> *newNode;
     newNode = new node<Type>;
     newNode->data = item;
@@ -61,42 +53,35 @@ void stack<Type>::push(Type item)
 
 /* Return the top element of the stack */
 template <class Type>
-Type stack<Type>::top()
-{
+Type stack<Type>::top() {
     assert(stackTop != NULL);
     return stackTop->data;
 }
 
 /* Remove the top element of the stack */
 template <class Type>
-void stack<Type>::pop()
-{
+void stack<Type>::pop() {
     node<Type> *temp;
-    if (!isEmptyStack())
-    {
+    if (!isEmptyStack()) {
         temp = stackTop;
         stackTop = stackTop->next;
         delete temp;
         size--;
-    }
-    else
-    {
+    } else {
         cout << "Stack is empty !" << endl;
     }
 }
 
 /* Operator "=" */
 template <class Type>
-stack<Type> stack<Type>::operator=(stack<Type> &otherStack)
-{
+stack<Type> stack<Type>::operator=(stack<Type> &otherStack) {
     node<Type> *newNode, *current, *last;
 
     if (stackTop != NULL) /* If stack is no empty, make it empty */
         stackTop = NULL;
     if (otherStack.stackTop == NULL)
         stackTop = NULL;
-    else
-    {
+    else {
         current = otherStack.stackTop;
         stackTop = new node<Type>;
         stackTop->data = current->data;
@@ -104,8 +89,7 @@ stack<Type> stack<Type>::operator=(stack<Type> &otherStack)
         last = stackTop;
         current = current->next;
         /* Copy the remaining stack */
-        while (current != NULL)
-        {
+        while (current != NULL) {
             newNode = new node<Type>;
             newNode->data = current->data;
             newNode->next = NULL;
diff --git a/data_structure/stk/stack.h b/data_structure/stk/stack.h
index 39b455ac0..da7788b73 100644
--- a/data_structure/stk/stack.h
+++ b/data_structure/stk/stack.h
@@ -4,16 +4,14 @@
 
 /* Definition of the node */
 template <class Type>
-struct node
-{
+struct node {
     Type data;
     node<Type> *next;
 };
 
 /* Definition of the stack class */
 template <class Type>
-class stack
-{
+class stack {
  public:
     void display();       /* Show stack */
     stack();              /* Default constructor*/
diff --git a/data_structure/stk/test_stack.cpp b/data_structure/stk/test_stack.cpp
index 8839fdfa3..098027dfd 100644
--- a/data_structure/stk/test_stack.cpp
+++ b/data_structure/stk/test_stack.cpp
@@ -4,8 +4,7 @@
 
 using namespace std;
 
-int main()
-{
+int main() {
     stack<int> stk;
     cout << "---------------------- Test construct ----------------------"
          << endl;
diff --git a/data_structure/tree.cpp b/data_structure/tree.cpp
index 92d139b72..f46c31ff2 100644
--- a/data_structure/tree.cpp
+++ b/data_structure/tree.cpp
@@ -2,17 +2,14 @@
 #include <list>
 using namespace std;
 
-struct node
-{
+struct node {
     int val;
     node *left;
     node *right;
 };
 
-void CreateTree(node *curr, node *n, int x, char pos)
-{
-    if (n != NULL)
-    {
+void CreateTree(node *curr, node *n, int x, char pos) {
+    if (n != NULL) {
         char ch;
         cout << "\nLeft or Right of " << n->val << " : ";
         cin >> ch;
@@ -20,32 +17,25 @@ void CreateTree(node *curr, node *n, int x, char pos)
             CreateTree(n, n->left, x, ch);
         else if (ch == 'r')
             CreateTree(n, n->right, x, ch);
-    }
-    else
-    {
+    } else {
         node *t = new node;
         t->val = x;
         t->left = NULL;
         t->right = NULL;
-        if (pos == 'l')
-        {
+        if (pos == 'l') {
             curr->left = t;
-        }
-        else if (pos == 'r')
-        {
+        } else if (pos == 'r') {
             curr->right = t;
         }
     }
 }
 
-void BFT(node *n)
-{
+void BFT(node *n) {
     list<node *> queue;
 
     queue.push_back(n);
 
-    while (!queue.empty())
-    {
+    while (!queue.empty()) {
         n = queue.front();
         cout << n->val << "  ";
         queue.pop_front();
@@ -57,38 +47,31 @@ void BFT(node *n)
     }
 }
 
-void Pre(node *n)
-{
-    if (n != NULL)
-    {
+void Pre(node *n) {
+    if (n != NULL) {
         cout << n->val << "  ";
         Pre(n->left);
         Pre(n->right);
     }
 }
 
-void In(node *n)
-{
-    if (n != NULL)
-    {
+void In(node *n) {
+    if (n != NULL) {
         In(n->left);
         cout << n->val << "  ";
         In(n->right);
     }
 }
 
-void Post(node *n)
-{
-    if (n != NULL)
-    {
+void Post(node *n) {
+    if (n != NULL) {
         Post(n->left);
         Post(n->right);
         cout << n->val << "  ";
     }
 }
 
-int main()
-{
+int main() {
     int value;
     int ch;
     node *root = new node;
@@ -97,8 +80,7 @@ int main()
     root->val = value;
     root->left = NULL;
     root->right = NULL;
-    do
-    {
+    do {
         cout << "\n1. Insert";
         cout << "\n2. Breadth First";
         cout << "\n3. Preorder Depth First";
@@ -107,8 +89,7 @@ int main()
 
         cout << "\nEnter Your Choice : ";
         cin >> ch;
-        switch (ch)
-        {
+        switch (ch) {
         case 1:
             int x;
             char pos;
diff --git a/data_structure/trie_tree.cpp b/data_structure/trie_tree.cpp
index d34dd2dbc..66b67fbc0 100644
--- a/data_structure/trie_tree.cpp
+++ b/data_structure/trie_tree.cpp
@@ -5,15 +5,13 @@
 #include <string>
 
 // structure definition
-typedef struct trie
-{
+typedef struct trie {
     struct trie* arr[26];
     bool isEndofWord;
 } trie;
 
 // create a new node for trie
-trie* createNode()
-{
+trie* createNode() {
     trie* nn = new trie();
     for (int i = 0; i < 26; i++) nn->arr[i] = NULL;
     nn->isEndofWord = false;
@@ -21,17 +19,12 @@ trie* createNode()
 }
 
 // insert string into the trie
-void insert(trie* root, std::string str)
-{
-    for (int i = 0; i < str.length(); i++)
-    {
+void insert(trie* root, std::string str) {
+    for (int i = 0; i < str.length(); i++) {
         int j = str[i] - 'a';
-        if (root->arr[j])
-        {
+        if (root->arr[j]) {
             root = root->arr[j];
-        }
-        else
-        {
+        } else {
             root->arr[j] = createNode();
             root = root->arr[j];
         }
@@ -40,10 +33,8 @@ void insert(trie* root, std::string str)
 }
 
 // search a string exists inside the trie
-bool search(trie* root, std::string str, int index)
-{
-    if (index == str.length())
-    {
+bool search(trie* root, std::string str, int index) {
+    if (index == str.length()) {
         if (!root->isEndofWord)
             return false;
         return true;
@@ -59,10 +50,8 @@ removes the string if it is not a prefix of any  other
 string, if it is then just sets the endofword to false, else
 removes the given string
 */
-bool deleteString(trie* root, std::string str, int index)
-{
-    if (index == str.length())
-    {
+bool deleteString(trie* root, std::string str, int index) {
+    if (index == str.length()) {
         if (!root->isEndofWord)
             return false;
         root->isEndofWord = false;
@@ -73,15 +62,11 @@ bool deleteString(trie* root, std::string str, int index)
     if (!root->arr[j])
         return false;
     bool var = deleteString(root, str, index + 1);
-    if (var)
-    {
+    if (var) {
         root->arr[j] = NULL;
-        if (root->isEndofWord)
-        {
+        if (root->isEndofWord) {
             return false;
-        }
-        else
-        {
+        } else {
             int i;
             for (i = 0; i < 26; i++)
                 if (root->arr[i])
@@ -91,8 +76,7 @@ bool deleteString(trie* root, std::string str, int index)
     }
 }
 
-int main()
-{
+int main() {
     trie* root = createNode();
     insert(root, "hello");
     insert(root, "world");
diff --git a/dynamic_programming/0_1_knapsack.cpp b/dynamic_programming/0_1_knapsack.cpp
index 0ce40ca0a..7ea0c04c6 100644
--- a/dynamic_programming/0_1_knapsack.cpp
+++ b/dynamic_programming/0_1_knapsack.cpp
@@ -28,13 +28,10 @@ using namespace std;
 //	}
 //}
 
-int Knapsack(int capacity, int n, int weight[], int value[])
-{
+int Knapsack(int capacity, int n, int weight[], int value[]) {
     int res[20][20];
-    for (int i = 0; i < n + 1; ++i)
-    {
-        for (int j = 0; j < capacity + 1; ++j)
-        {
+    for (int i = 0; i < n + 1; ++i) {
+        for (int j = 0; j < capacity + 1; ++j) {
             if (i == 0 || j == 0)
                 res[i][j] = 0;
             else if (weight[i - 1] <= j)
@@ -48,20 +45,17 @@ int Knapsack(int capacity, int n, int weight[], int value[])
     //	cout<<"\n";
     return res[n][capacity];
 }
-int main()
-{
+int main() {
     int n;
     cout << "Enter number of items: ";
     cin >> n;
     int weight[n], value[n];
     cout << "Enter weights: ";
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         cin >> weight[i];
     }
     cout << "Enter values: ";
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         cin >> value[i];
     }
     int capacity;
diff --git a/dynamic_programming/armstrong_number.cpp b/dynamic_programming/armstrong_number.cpp
index 218d6365d..270a705f7 100644
--- a/dynamic_programming/armstrong_number.cpp
+++ b/dynamic_programming/armstrong_number.cpp
@@ -4,14 +4,12 @@
 using std::cin;
 using std::cout;
 
-int main()
-{
+int main() {
     int n, k, d, s = 0;
     cout << "Enter a number:";
     cin >> n;
     k = n;
-    while (k != 0)
-    {
+    while (k != 0) {
         d = k % 10;
         s += d * d * d;
         k /= 10;
diff --git a/dynamic_programming/bellman_ford.cpp b/dynamic_programming/bellman_ford.cpp
index 85d3bff06..c96f3fd8e 100644
--- a/dynamic_programming/bellman_ford.cpp
+++ b/dynamic_programming/bellman_ford.cpp
@@ -4,33 +4,28 @@
 using namespace std;
 
 // Wrapper class for storing an edge
-class Edge
-{
+class Edge {
  public:
     int src, dst, weight;
 };
 
 // Wrapper class for storing a graph
-class Graph
-{
+class Graph {
  public:
     int vertexNum, edgeNum;
     Edge *edges;
 
     // Constructs a graph with V vertices and E edges
-    Graph(int V, int E)
-    {
+    Graph(int V, int E) {
         this->vertexNum = V;
         this->edgeNum = E;
         this->edges = (Edge *)malloc(E * sizeof(Edge));
     }
 
     // Adds the given edge to the graph
-    void addEdge(int src, int dst, int weight)
-    {
+    void addEdge(int src, int dst, int weight) {
         static int edgeInd = 0;
-        if (edgeInd < this->edgeNum)
-        {
+        if (edgeInd < this->edgeNum) {
             Edge newEdge;
             newEdge.src = src;
             newEdge.dst = dst;
@@ -41,11 +36,9 @@ class Graph
 };
 
 // Utility function to print distances
-void print(int dist[], int V)
-{
+void print(int dist[], int V) {
     cout << "\nVertex  Distance" << endl;
-    for (int i = 0; i < V; i++)
-    {
+    for (int i = 0; i < V; i++) {
         if (dist[i] != INT_MAX)
             cout << i << "\t" << dist[i] << endl;
         else
@@ -56,8 +49,7 @@ void print(int dist[], int V)
 // The main function that finds the shortest path from given source
 // to all other vertices using Bellman-Ford.It also detects negative
 // weight cycle
-void BellmanFord(Graph graph, int src)
-{
+void BellmanFord(Graph graph, int src) {
     int V = graph.vertexNum;
     int E = graph.edgeNum;
     int dist[V];
@@ -70,8 +62,7 @@ void BellmanFord(Graph graph, int src)
     // Calculate shortest path distance from source to all edges
     // A path can contain maximum (|V|-1) edges
     for (int i = 0; i <= V - 1; i++)
-        for (int j = 0; j < E; j++)
-        {
+        for (int j = 0; j < E; j++) {
             int u = graph.edges[j].src;
             int v = graph.edges[j].dst;
             int w = graph.edges[j].weight;
@@ -81,14 +72,12 @@ void BellmanFord(Graph graph, int src)
         }
 
     // Iterate inner loop once more to check for negative cycle
-    for (int j = 0; j < E; j++)
-    {
+    for (int j = 0; j < E; j++) {
         int u = graph.edges[j].src;
         int v = graph.edges[j].dst;
         int w = graph.edges[j].weight;
 
-        if (dist[u] != INT_MAX && dist[u] + w < dist[v])
-        {
+        if (dist[u] != INT_MAX && dist[u] + w < dist[v]) {
             cout << "Graph contains negative weight cycle. Hence, shortest "
                     "distance not guaranteed."
                  << endl;
@@ -102,8 +91,7 @@ void BellmanFord(Graph graph, int src)
 }
 
 // Driver Function
-int main()
-{
+int main() {
     int V, E, gsrc;
     int src, dst, weight;
     cout << "Enter number of vertices: ";
@@ -111,8 +99,7 @@ int main()
     cout << "Enter number of edges: ";
     cin >> E;
     Graph G(V, E);
-    for (int i = 0; i < E; i++)
-    {
+    for (int i = 0; i < E; i++) {
         cout << "\nEdge " << i + 1 << "\nEnter source: ";
         cin >> src;
         cout << "Enter destination: ";
diff --git a/dynamic_programming/catalan_numbers.cpp b/dynamic_programming/catalan_numbers.cpp
index 0107b9f20..f5edaa916 100644
--- a/dynamic_programming/catalan_numbers.cpp
+++ b/dynamic_programming/catalan_numbers.cpp
@@ -11,8 +11,7 @@ using namespace std;
 
 int *cat;  // global array to hold catalan numbers
 
-unsigned long int catalan_dp(int n)
-{
+unsigned long int catalan_dp(int n) {
     /** Using the tabulation technique in dynamic programming,
         this function computes the first `n+1` Catalan numbers
 
@@ -29,8 +28,7 @@ unsigned long int catalan_dp(int n)
     cat[0] = cat[1] = 1;
 
     // Compute the remaining numbers from index 2 to index n, using tabulation
-    for (int i = 2; i <= n; i++)
-    {
+    for (int i = 2; i <= n; i++) {
         cat[i] = 0;
         for (int j = 0; j < i; j++)
             cat[i] += cat[j] * cat[i - j - 1];  // applying the definition here
@@ -40,8 +38,7 @@ unsigned long int catalan_dp(int n)
     return cat[n];
 }
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     int n;
     cout << "Enter n: ";
     cin >> n;
@@ -49,8 +46,7 @@ int main(int argc, char *argv[])
     cat = new int[n + 1];
 
     cout << "Catalan numbers from 0 to " << n << " are:\n";
-    for (int i = 0; i <= n; i++)
-    {
+    for (int i = 0; i <= n; i++) {
         cout << "catalan (" << i << ") = " << catalan_dp(i) << endl;
         // NOTE: Since `cat` is a global array, calling `catalan_dp`
         // repeatedly will not recompute the the values already computed
diff --git a/dynamic_programming/coin_change.cpp b/dynamic_programming/coin_change.cpp
index f43d4fa18..8c8fc3dfb 100644
--- a/dynamic_programming/coin_change.cpp
+++ b/dynamic_programming/coin_change.cpp
@@ -3,8 +3,7 @@
 using namespace std;
 
 // Function to find the Minimum number of coins required to get Sum S
-int findMinCoins(int arr[], int n, int N)
-{
+int findMinCoins(int arr[], int n, int N) {
     // dp[i] = no of coins required to get a total of i
     int dp[N + 1];
 
@@ -12,15 +11,13 @@ int findMinCoins(int arr[], int n, int N)
 
     dp[0] = 0;
 
-    for (int i = 1; i <= N; i++)
-    {
+    for (int i = 1; i <= N; i++) {
         // initialize minimum number of coins needed to infinity
         dp[i] = INT_MAX;
         int res = INT_MAX;
 
         // do for each coin
-        for (int c = 0; c < n; c++)
-        {
+        for (int c = 0; c < n; c++) {
             if (i - arr[c] >=
                 0)  // check if coins doesn't become negative by including it
                 res = dp[i - arr[c]];
@@ -36,8 +33,7 @@ int findMinCoins(int arr[], int n, int N)
     return dp[N];
 }
 
-int main()
-{
+int main() {
     // No of Coins We Have
     int arr[] = {1, 2, 3, 4};
     int n = sizeof(arr) / sizeof(arr[0]);
diff --git a/dynamic_programming/cut_rod.cpp b/dynamic_programming/cut_rod.cpp
index 3df0a9fbe..136c78dbb 100644
--- a/dynamic_programming/cut_rod.cpp
+++ b/dynamic_programming/cut_rod.cpp
@@ -5,23 +5,19 @@ the pieces.*/
 
 #include <iostream>
 using namespace std;
-int cutrod(int p[], int n)
-{
+int cutrod(int p[], int n) {
     int r[n + 1];
     r[0] = 0;
-    for (int j = 0; j < n; j++)
-    {
+    for (int j = 0; j < n; j++) {
         int q = INT_MIN;
-        for (int i = 0; i <= j; i++)
-        {
+        for (int i = 0; i <= j; i++) {
             q = max(q, p[i] + r[j - i]);
         }
         r[j + 1] = q;
     }
     return r[n];
 }
-int main()
-{
+int main() {
     int price[] = {1,  5,  8,  9,  10, 17, 17, 20, 24, 30, 31, 32, 33, 34, 35,
                    36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
     cout << cutrod(price, 30);
diff --git a/dynamic_programming/edit_distance.cpp b/dynamic_programming/edit_distance.cpp
index da613b238..889b080cb 100644
--- a/dynamic_programming/edit_distance.cpp
+++ b/dynamic_programming/edit_distance.cpp
@@ -22,8 +22,7 @@ int min(int x, int y, int z) { return min(min(x, y), z); }
  * str1 to str2.
  * O(3^m)
  */
-int editDist(string str1, string str2, int m, int n)
-{
+int editDist(string str1, string str2, int m, int n) {
     if (m == 0)
         return n;
     if (n == 0)
@@ -45,16 +44,13 @@ int editDist(string str1, string str2, int m, int n)
 /* A DP based program
  * O(m x n)
  */
-int editDistDP(string str1, string str2, int m, int n)
-{
+int editDistDP(string str1, string str2, int m, int n) {
     // Create Table for SubProblems
     int dp[m + 1][n + 1];
 
     // Fill d[][] in bottom up manner
-    for (int i = 0; i <= m; i++)
-    {
-        for (int j = 0; j <= n; j++)
-        {
+    for (int i = 0; i <= m; i++) {
+        for (int j = 0; j <= n; j++) {
             // If str1 empty. Then add all of str2
             if (i == 0)
                 dp[i][j] = j;
@@ -78,8 +74,7 @@ int editDistDP(string str1, string str2, int m, int n)
     return dp[m][n];
 }
 
-int main()
-{
+int main() {
     string str1 = "sunday";
     string str2 = "saturday";
 
diff --git a/dynamic_programming/egg_dropping_puzzle.cpp b/dynamic_programming/egg_dropping_puzzle.cpp
index 79de4cc22..7a769ea47 100644
--- a/dynamic_programming/egg_dropping_puzzle.cpp
+++ b/dynamic_programming/egg_dropping_puzzle.cpp
@@ -6,30 +6,24 @@
 #include <iostream>
 using namespace std;
 
-int eggDrop(int n, int k)
-{
+int eggDrop(int n, int k) {
     int eggFloor[n + 1][k + 1];
     int result;
 
-    for (int i = 1; i <= n; i++)
-    {
+    for (int i = 1; i <= n; i++) {
         eggFloor[i][1] = 1;  // n eggs..1 Floor
         eggFloor[i][0] = 0;  // n eggs..0 Floor
     }
 
     // Only one egg available
-    for (int j = 1; j <= k; j++)
-    {
+    for (int j = 1; j <= k; j++) {
         eggFloor[1][j] = j;
     }
 
-    for (int i = 2; i <= n; i++)
-    {
-        for (int j = 2; j <= k; j++)
-        {
+    for (int i = 2; i <= n; i++) {
+        for (int j = 2; j <= k; j++) {
             eggFloor[i][j] = INT_MAX;
-            for (int x = 1; x <= j; x++)
-            {
+            for (int x = 1; x <= j; x++) {
                 // 1+max(eggBreak[one less egg, lower floors],
                 //       eggDoesntBreak[same # of eggs, upper floors]);
                 result = 1 + max(eggFloor[i - 1][x - 1], eggFloor[i][j - x]);
@@ -42,8 +36,7 @@ int eggDrop(int n, int k)
     return eggFloor[n][k];
 }
 
-int main()
-{
+int main() {
     int n, k;
     cout << "Enter number of eggs and floors: ";
     cin >> n >> k;
diff --git a/dynamic_programming/fibonacci_bottom_up.cpp b/dynamic_programming/fibonacci_bottom_up.cpp
index 3a9669fa9..555f15282 100644
--- a/dynamic_programming/fibonacci_bottom_up.cpp
+++ b/dynamic_programming/fibonacci_bottom_up.cpp
@@ -1,20 +1,17 @@
 #include <iostream>
 using namespace std;
-int fib(int n)
-{
+int fib(int n) {
     int res[3];
     res[0] = 0;
     res[1] = 1;
-    for (int i = 2; i <= n; i++)
-    {
+    for (int i = 2; i <= n; i++) {
         res[2] = res[1] + res[0];
         res[0] = res[1];
         res[1] = res[2];
     }
     return res[1];
 }
-int main(int argc, char const *argv[])
-{
+int main(int argc, char const *argv[]) {
     int n;
     cout << "Enter n: ";
     cin >> n;
diff --git a/dynamic_programming/fibonacci_top_down.cpp b/dynamic_programming/fibonacci_top_down.cpp
index 3ac3fdb40..3c0c9a1a3 100644
--- a/dynamic_programming/fibonacci_top_down.cpp
+++ b/dynamic_programming/fibonacci_top_down.cpp
@@ -1,10 +1,8 @@
 #include <iostream>
 using namespace std;
 int arr[1000000];
-int fib(int n)
-{
-    if (arr[n] == -1)
-    {
+int fib(int n) {
+    if (arr[n] == -1) {
         if (n <= 1)
             arr[n] = n;
         else
@@ -12,13 +10,11 @@ int fib(int n)
     }
     return arr[n];
 }
-int main(int argc, char const *argv[])
-{
+int main(int argc, char const *argv[]) {
     int n;
     cout << "Enter n: ";
     cin >> n;
-    for (int i = 0; i < n + 1; ++i)
-    {
+    for (int i = 0; i < n + 1; ++i) {
         arr[i] = -1;
     }
     cout << "Fibonacci number is " << fib(n) << endl;
diff --git a/dynamic_programming/kadane.cpp b/dynamic_programming/kadane.cpp
index 31d17ae9e..b5272756b 100644
--- a/dynamic_programming/kadane.cpp
+++ b/dynamic_programming/kadane.cpp
@@ -1,12 +1,10 @@
 #include <climits>
 #include <iostream>
 
-int maxSubArraySum(int a[], int size)
-{
+int maxSubArraySum(int a[], int size) {
     int max_so_far = INT_MIN, max_ending_here = 0;
 
-    for (int i = 0; i < size; i++)
-    {
+    for (int i = 0; i < size; i++) {
         max_ending_here = max_ending_here + a[i];
         if (max_so_far < max_ending_here)
             max_so_far = max_ending_here;
@@ -17,14 +15,12 @@ int maxSubArraySum(int a[], int size)
     return max_so_far;
 }
 
-int main()
-{
+int main() {
     int n, i;
     std::cout << "Enter the number of elements \n";
     std::cin >> n;
     int a[n];  // NOLINT
-    for (i = 0; i < n; i++)
-    {
+    for (i = 0; i < n; i++) {
         std::cin >> a[i];
     }
     int max_sum = maxSubArraySum(a, n);
diff --git a/dynamic_programming/longest_common_string.cpp b/dynamic_programming/longest_common_string.cpp
index e33489cb1..81fa8a002 100644
--- a/dynamic_programming/longest_common_string.cpp
+++ b/dynamic_programming/longest_common_string.cpp
@@ -3,8 +3,7 @@ using namespace std;
 
 int max(int a, int b) { return (a > b) ? a : b; }
 
-int main()
-{
+int main() {
     char str1[] = "DEFBCD";
     char str2[] = "ABDEFJ";
     int i, j, k;
@@ -13,10 +12,8 @@ int main()
     // cout<<n<<" "<<m<<"\n";
     int a[m][n];
 
-    for (i = 0; i < m; i++)
-    {
-        for (j = 0; j < n; j++)
-        {
+    for (i = 0; i < m; i++) {
+        for (j = 0; j < n; j++) {
             if (i == 0 || j == 0)
                 a[i][j] = 0;
 
@@ -37,12 +34,9 @@ int main()
 
     int ma = -1;
     int indi, indj;
-    for (i = 0; i < m; i++)
-    {
-        for (j = 0; j < n; j++)
-        {
-            if (a[i][j] > ma)
-            {
+    for (i = 0; i < m; i++) {
+        for (j = 0; j < n; j++) {
+            if (a[i][j] > ma) {
                 ma = a[i][j];
                 indi = i;
                 indj = j;
diff --git a/dynamic_programming/longest_common_subsequence.cpp b/dynamic_programming/longest_common_subsequence.cpp
index 7973bb05e..662c26ad2 100644
--- a/dynamic_programming/longest_common_subsequence.cpp
+++ b/dynamic_programming/longest_common_subsequence.cpp
@@ -2,69 +2,50 @@
 #include <iostream>
 using namespace std;
 
-void Print(int trace[20][20], int m, int n, string a)
-{
-    if (m == 0 || n == 0)
-    {
+void Print(int trace[20][20], int m, int n, string a) {
+    if (m == 0 || n == 0) {
         return;
     }
-    if (trace[m][n] == 1)
-    {
+    if (trace[m][n] == 1) {
         Print(trace, m - 1, n - 1, a);
         cout << a[m - 1];
-    }
-    else if (trace[m][n] == 2)
-    {
+    } else if (trace[m][n] == 2) {
         Print(trace, m - 1, n, a);
-    }
-    else if (trace[m][n] == 3)
-    {
+    } else if (trace[m][n] == 3) {
         Print(trace, m, n - 1, a);
     }
 }
 
-int lcs(string a, string b)
-{
+int lcs(string a, string b) {
     int m = a.length(), n = b.length();
     int res[m + 1][n + 1];
     int trace[20][20];
 
     // fills up the arrays with zeros.
-    for (int i = 0; i < m + 1; i++)
-    {
-        for (int j = 0; j < n + 1; j++)
-        {
+    for (int i = 0; i < m + 1; i++) {
+        for (int j = 0; j < n + 1; j++) {
             res[i][j] = 0;
             trace[i][j] = 0;
         }
     }
 
-    for (int i = 0; i < m + 1; ++i)
-    {
-        for (int j = 0; j < n + 1; ++j)
-        {
-            if (i == 0 || j == 0)
-            {
+    for (int i = 0; i < m + 1; ++i) {
+        for (int j = 0; j < n + 1; ++j) {
+            if (i == 0 || j == 0) {
                 res[i][j] = 0;
                 trace[i][j] = 0;
             }
 
-            else if (a[i - 1] == b[j - 1])
-            {
+            else if (a[i - 1] == b[j - 1]) {
                 res[i][j] = 1 + res[i - 1][j - 1];
                 trace[i][j] = 1;  // 1 means trace the matrix in upper left
                                   // diagonal direction.
-            }
-            else
-            {
-                if (res[i - 1][j] > res[i][j - 1])
-                {
+            } else {
+                if (res[i - 1][j] > res[i][j - 1]) {
                     res[i][j] = res[i - 1][j];
                     trace[i][j] =
                         2;  // 2 means trace the matrix in upwards direction.
-                }
-                else
-                {
+                } else {
                     res[i][j] = res[i][j - 1];
                     trace[i][j] =
                         3;  //  means trace the matrix in left direction.
@@ -76,8 +57,7 @@ int lcs(string a, string b)
     return res[m][n];
 }
 
-int main()
-{
+int main() {
     string a, b;
     cin >> a >> b;
     cout << lcs(a, b);
diff --git a/dynamic_programming/longest_increasing_subsequence.cpp b/dynamic_programming/longest_increasing_subsequence.cpp
index 573db34a5..b6a798aa0 100644
--- a/dynamic_programming/longest_increasing_subsequence.cpp
+++ b/dynamic_programming/longest_increasing_subsequence.cpp
@@ -1,37 +1,30 @@
 // Program to calculate length of longest increasing subsequence in an array
 #include <bits/stdc++.h>
 using namespace std;
-int LIS(int a[], int n)
-{
+int LIS(int a[], int n) {
     int lis[n];
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         lis[i] = 1;
     }
-    for (int i = 0; i < n; ++i)
-    {
-        for (int j = 0; j < i; ++j)
-        {
+    for (int i = 0; i < n; ++i) {
+        for (int j = 0; j < i; ++j) {
             if (a[i] > a[j] && lis[i] < lis[j] + 1)
                 lis[i] = lis[j] + 1;
         }
     }
     int res = 0;
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         res = max(res, lis[i]);
     }
     return res;
 }
-int main(int argc, char const *argv[])
-{
+int main(int argc, char const *argv[]) {
     int n;
     cout << "Enter size of array: ";
     cin >> n;
     int a[n];
     cout << "Enter array elements: ";
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         cin >> a[i];
     }
     cout << LIS(a, n) << endl;
diff --git a/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp b/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
index 2471b701f..5bc72345c 100644
--- a/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
+++ b/dynamic_programming/longest_increasing_subsequence_(nlogn).cpp
@@ -5,24 +5,19 @@
 #include <iostream>
 
 using namespace std;
-int LIS(int arr[], int n)
-{
+int LIS(int arr[], int n) {
     set<int> active;  // The current built LIS.
     active.insert(arr[0]);
     // Loop through every element.
-    for (int i = 1; i < n; ++i)
-    {
+    for (int i = 1; i < n; ++i) {
         auto get = active.lower_bound(arr[i]);
-        if (get == active.end())
-        {
+        if (get == active.end()) {
             active.insert(arr[i]);
         }  // current element is the greatest so LIS increases by 1.
-        else
-        {
+        else {
             int val = *get;  // we find the position where arr[i] will be in the
                              // LIS. If it is in the LIS already we do nothing
-            if (val > arr[i])
-            {
+            if (val > arr[i]) {
                 // else we remove the bigger element and add a smaller element
                 // (which is arr[i]) and continue;
                 active.erase(get);
@@ -32,15 +27,13 @@ int LIS(int arr[], int n)
     }
     return active.size();  // size of the LIS.
 }
-int main(int argc, char const* argv[])
-{
+int main(int argc, char const* argv[]) {
     int n;
     cout << "Enter size of array: ";
     cin >> n;
     int a[n];
     cout << "Enter array elements: ";
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         cin >> a[i];
     }
     cout << LIS(a, n) << endl;
diff --git a/dynamic_programming/matrix_chain_multiplication.cpp b/dynamic_programming/matrix_chain_multiplication.cpp
index 378edcc7f..7d6647c52 100644
--- a/dynamic_programming/matrix_chain_multiplication.cpp
+++ b/dynamic_programming/matrix_chain_multiplication.cpp
@@ -9,8 +9,7 @@ int dp[MAX][MAX];
 
 // Function to find the most efficient way to multiply the given sequence of
 // matrices
-int MatrixChainMultiplication(int dim[], int i, int j)
-{
+int MatrixChainMultiplication(int dim[], int i, int j) {
     // base case: one matrix
     if (j <= i + 1)
         return 0;
@@ -21,13 +20,11 @@ int MatrixChainMultiplication(int dim[], int i, int j)
 
     // if dp[i][j] is not calculated (calculate it!!)
 
-    if (dp[i][j] == 0)
-    {
+    if (dp[i][j] == 0) {
         // take the minimum over each possible position at which the
         // sequence of matrices can be split
 
-        for (int k = i + 1; k <= j - 1; k++)
-        {
+        for (int k = i + 1; k <= j - 1; k++) {
             // recur for M[i+1]..M[k] to get a i x k matrix
             int cost = MatrixChainMultiplication(dim, i, k);
 
@@ -48,8 +45,7 @@ int MatrixChainMultiplication(int dim[], int i, int j)
 }
 
 // main function
-int main()
-{
+int main() {
     // Matrix i has Dimensions dim[i-1] & dim[i] for i=1..n
     // input is 10 x 30 matrix, 30 x 5 matrix, 5 x 60 matrix
     int dim[] = {10, 30, 5, 60};
diff --git a/dynamic_programming/searching_of_element_in_dynamic_array.cpp b/dynamic_programming/searching_of_element_in_dynamic_array.cpp
index 3dea46bf4..7792a5149 100644
--- a/dynamic_programming/searching_of_element_in_dynamic_array.cpp
+++ b/dynamic_programming/searching_of_element_in_dynamic_array.cpp
@@ -35,8 +35,7 @@
 
 // this is main fuction
 // ***
-int main()
-{
+int main() {
     int64_t r, mr = 0, x, q, i, z;
     std::cout << "Enter Number of array you want to Store :";
     std::cin >> x;
@@ -50,8 +49,7 @@ int main()
     int** ar = new int*[x]();
     // this for loop is use for entering different variable size array
     // ***
-    for (r = 0; r < x; r++)
-    {
+    for (r = 0; r < x; r++) {
         std::cout << "Enter number of element in " << r + 1 << " rows :";
         std::cin >> mr;
         // creating a 1D array
@@ -59,8 +57,7 @@ int main()
         std::cout << "Enter the element of Array ";
         // this for loop is use for storing values in array
         // ***
-        for (i = 0; i < mr; i++)
-        {
+        for (i = 0; i < mr; i++) {
             // entering the value of rows in array in Horizontal
             std::cin >> ac[i];
         }
@@ -69,8 +66,7 @@ int main()
     }
     // this for loop is use for display result of querry
     // ***
-    for (z = 0; z < q; z++)
-    {
+    for (z = 0; z < q; z++) {
         int64_t r1 = 0, q1 = 0;
         std::cout << "enter the number of row which element you want to find :";
         std::cin >> r1;
diff --git a/dynamic_programming/tree_height.cpp b/dynamic_programming/tree_height.cpp
index 1530dfe7e..480b951c8 100644
--- a/dynamic_programming/tree_height.cpp
+++ b/dynamic_programming/tree_height.cpp
@@ -29,14 +29,11 @@ std::vector<int> adj[MAX];
 std::vector<bool> visited;
 std::vector<int> dp;
 
-void depth_first_search(int u)
-{
+void depth_first_search(int u) {
     visited[u] = true;
     int child_height = 1;
-    for (int v : adj[u])
-    {
-        if (!visited[v])
-        {
+    for (int v : adj[u]) {
+        if (!visited[v]) {
             depth_first_search(v);
 
             // select maximum sub-tree height from all children.
@@ -47,8 +44,7 @@ void depth_first_search(int u)
     dp[u] = child_height;
 }
 
-int main()
-{
+int main() {
     // number of nodes
     int number_of_nodes;
     std::cout << "Enter number of nodes of the tree : " << std::endl;
@@ -58,8 +54,7 @@ int main()
     int u, v;
     // Tree contains exactly n-1 edges where n denotes the number of nodes.
     std::cout << "Enter edges of the tree : " << std::endl;
-    for (int i = 0; i < number_of_nodes - 1; i++)
-    {
+    for (int i = 0; i < number_of_nodes - 1; i++) {
         std::cin >> u >> v;
         // undirected tree u -> v and v -> u.
         adj[u].push_back(v);
diff --git a/graph/bfs.cpp b/graph/bfs.cpp
index f5d372134..3acee8f80 100644
--- a/graph/bfs.cpp
+++ b/graph/bfs.cpp
@@ -1,7 +1,6 @@
 #include <iostream>
 using namespace std;
-class graph
-{
+class graph {
     int v;
     list<int> *adj;
 
@@ -11,56 +10,46 @@ class graph
     void printgraph();
     void bfs(int s);
 };
-graph::graph(int v)
-{
+graph::graph(int v) {
     this->v = v;
     this->adj = new list<int>[v];
 }
-void graph::addedge(int src, int dest)
-{
+void graph::addedge(int src, int dest) {
     src--;
     dest--;
     adj[src].push_back(dest);
     // adj[dest].push_back(src);
 }
-void graph::printgraph()
-{
-    for (int i = 0; i < this->v; i++)
-    {
+void graph::printgraph() {
+    for (int i = 0; i < this->v; i++) {
         cout << "Adjacency list of vertex " << i + 1 << " is \n";
         list<int>::iterator it;
-        for (it = adj[i].begin(); it != adj[i].end(); ++it)
-        {
+        for (it = adj[i].begin(); it != adj[i].end(); ++it) {
             cout << *it + 1 << " ";
         }
         cout << endl;
     }
 }
-void graph::bfs(int s)
-{
+void graph::bfs(int s) {
     bool *visited = new bool[this->v + 1];
     memset(visited, false, sizeof(bool) * (this->v + 1));
     visited[s] = true;
     list<int> q;
     q.push_back(s);
     list<int>::iterator it;
-    while (!q.empty())
-    {
+    while (!q.empty()) {
         int u = q.front();
         cout << u << " ";
         q.pop_front();
-        for (it = adj[u].begin(); it != adj[u].end(); ++it)
-        {
-            if (visited[*it] == false)
-            {
+        for (it = adj[u].begin(); it != adj[u].end(); ++it) {
+            if (visited[*it] == false) {
                 visited[*it] = true;
                 q.push_back(*it);
             }
         }
     }
 }
-int main()
-{
+int main() {
     graph g(4);
     g.addedge(1, 2);
     g.addedge(2, 3);
diff --git a/graph/bridge_finding_with_tarjan_algorithm.cpp b/graph/bridge_finding_with_tarjan_algorithm.cpp
index a283a7c91..eec176af5 100644
--- a/graph/bridge_finding_with_tarjan_algorithm.cpp
+++ b/graph/bridge_finding_with_tarjan_algorithm.cpp
@@ -10,28 +10,22 @@
 using std::cout;
 using std::min;
 using std::vector;
-class Solution
-{
+class Solution {
     vector<vector<int>> graph;
     vector<int> in_time, out_time;
     int timer;
     vector<vector<int>> bridge;
     vector<bool> visited;
-    void dfs(int current_node, int parent)
-    {
+    void dfs(int current_node, int parent) {
         visited.at(current_node) = true;
         in_time[current_node] = out_time[current_node] = timer++;
-        for (auto& itr : graph[current_node])
-        {
-            if (itr == parent)
-            {
+        for (auto& itr : graph[current_node]) {
+            if (itr == parent) {
                 continue;
             }
-            if (!visited[itr])
-            {
+            if (!visited[itr]) {
                 dfs(itr, current_node);
-                if (out_time[itr] > in_time[current_node])
-                {
+                if (out_time[itr] > in_time[current_node]) {
                     bridge.push_back({itr, current_node});
                 }
             }
@@ -41,15 +35,13 @@ class Solution
 
  public:
     vector<vector<int>> search_bridges(int n,
-                                       const vector<vector<int>>& connections)
-    {
+                                       const vector<vector<int>>& connections) {
         timer = 0;
         graph.resize(n);
         in_time.assign(n, 0);
         visited.assign(n, false);
         out_time.assign(n, 0);
-        for (auto& itr : connections)
-        {
+        for (auto& itr : connections) {
             graph.at(itr[0]).push_back(itr[1]);
             graph.at(itr[1]).push_back(itr[0]);
         }
@@ -57,8 +49,7 @@ class Solution
         return bridge;
     }
 };
-int main(void)
-{
+int main(void) {
     Solution s1;
     int number_of_node = 5;
     vector<vector<int>> node;
@@ -81,8 +72,7 @@ int main(void)
      */
     vector<vector<int>> bridges = s1.search_bridges(number_of_node, node);
     cout << bridges.size() << " bridges found!\n";
-    for (auto& itr : bridges)
-    {
+    for (auto& itr : bridges) {
         cout << itr[0] << " --> " << itr[1] << '\n';
     }
     return 0;
diff --git a/graph/connected_components.cpp b/graph/connected_components.cpp
index f78ef011e..0bfb8bbdb 100644
--- a/graph/connected_components.cpp
+++ b/graph/connected_components.cpp
@@ -3,8 +3,7 @@
 
 using std::vector;
 
-class graph
-{
+class graph {
  private:
     vector<vector<int>> adj;
     int connected_components;
@@ -14,48 +13,39 @@ class graph
  public:
     explicit graph(int n) : adj(n, vector<int>()) { connected_components = 0; }
     void addEdge(int, int);
-    int getConnectedComponents()
-    {
+    int getConnectedComponents() {
         depth_first_search();
         return connected_components;
     }
 };
 
-void graph::addEdge(int u, int v)
-{
+void graph::addEdge(int u, int v) {
     adj[u - 1].push_back(v - 1);
     adj[v - 1].push_back(u - 1);
 }
 
-void graph::depth_first_search()
-{
+void graph::depth_first_search() {
     int n = adj.size();
     vector<bool> visited(n, false);
 
-    for (int i = 0; i < n; i++)
-    {
-        if (!visited[i])
-        {
+    for (int i = 0; i < n; i++) {
+        if (!visited[i]) {
             explore(i, visited);
             connected_components++;
         }
     }
 }
 
-void graph::explore(int u, vector<bool> &visited)
-{
+void graph::explore(int u, vector<bool> &visited) {
     visited[u] = true;
-    for (auto v : adj[u])
-    {
-        if (!visited[v])
-        {
+    for (auto v : adj[u]) {
+        if (!visited[v]) {
             explore(v, visited);
         }
     }
 }
 
-int main()
-{
+int main() {
     graph g(4);
     g.addEdge(1, 2);
     g.addEdge(3, 2);
diff --git a/graph/connected_components_with_dsu.cpp b/graph/connected_components_with_dsu.cpp
index 07fda5d27..aa03bef8f 100644
--- a/graph/connected_components_with_dsu.cpp
+++ b/graph/connected_components_with_dsu.cpp
@@ -5,28 +5,23 @@
 int N;  // denotes number of nodes;
 std::vector<int> parent;
 std::vector<int> siz;
-void make_set()
-{  // function the initialize every node as it's own parent
-    for (int i = 1; i <= N; i++)
-    {
+void make_set() {  // function the initialize every node as it's own parent
+    for (int i = 1; i <= N; i++) {
         parent[i] = i;
         siz[i] = 1;
     }
 }
 // To find the component where following node belongs to
-int find_set(int v)
-{
+int find_set(int v) {
     if (v == parent[v])
         return v;
     return parent[v] = find_set(parent[v]);
 }
 
-void union_sets(int a, int b)
-{  // To join 2 components to belong to one
+void union_sets(int a, int b) {  // To join 2 components to belong to one
     a = find_set(a);
     b = find_set(b);
-    if (a != b)
-    {
+    if (a != b) {
         if (siz[a] < siz[b])
             std::swap(a, b);
         parent[b] = a;
@@ -34,8 +29,7 @@ void union_sets(int a, int b)
     }
 }
 
-int no_of_connected_components()
-{                        // To find total no of connected components
+int no_of_connected_components() {  // To find total no of connected components
     std::set<int> temp;  // temp set to count number of connected components
     for (int i = 1; i <= N; i++) temp.insert(find_set(i));
     return temp.size();
@@ -43,16 +37,14 @@ int no_of_connected_components()
 
 // All critical/corner cases have been taken care of.
 // Input your required values: (not hardcoded)
-int main()
-{
+int main() {
     std::cin >> N;
     parent.resize(N + 1);
     siz.resize(N + 1);
     make_set();
     int edges;
     std::cin >> edges;  // no of edges in the graph
-    while (edges--)
-    {
+    while (edges--) {
         int node_a, node_b;
         std::cin >> node_a >> node_b;
         union_sets(node_a, node_b);
diff --git a/graph/dfs.cpp b/graph/dfs.cpp
index 7c7ec7761..2d38c8725 100644
--- a/graph/dfs.cpp
+++ b/graph/dfs.cpp
@@ -1,28 +1,23 @@
 #include <iostream>
 using namespace std;
 int v = 4;
-void DFSUtil_(int graph[4][4], bool visited[], int s)
-{
+void DFSUtil_(int graph[4][4], bool visited[], int s) {
     visited[s] = true;
     cout << s << " ";
-    for (int i = 0; i < v; i++)
-    {
-        if (graph[s][i] == 1 && visited[i] == false)
-        {
+    for (int i = 0; i < v; i++) {
+        if (graph[s][i] == 1 && visited[i] == false) {
             DFSUtil_(graph, visited, i);
         }
     }
 }
 
-void DFS_(int graph[4][4], int s)
-{
+void DFS_(int graph[4][4], int s) {
     bool visited[v];
     memset(visited, 0, sizeof(visited));
     DFSUtil_(graph, visited, s);
 }
 
-int main()
-{
+int main() {
     int graph[4][4] = {{0, 1, 1, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}, {0, 0, 0, 1}};
     cout << "DFS: ";
     DFS_(graph, 2);
diff --git a/graph/dfs_with_stack.cpp b/graph/dfs_with_stack.cpp
index cc67c7509..193f3f291 100644
--- a/graph/dfs_with_stack.cpp
+++ b/graph/dfs_with_stack.cpp
@@ -11,8 +11,7 @@ using namespace std;
 
 int checked[999] = {WHITE};
 
-void dfs(const list<int> lista[], int start)
-{
+void dfs(const list<int> lista[], int start) {
     stack<int> stack;
 
     int checked[999] = {WHITE};
@@ -20,33 +19,28 @@ void dfs(const list<int> lista[], int start)
     stack.push(start);
 
     checked[start] = GREY;
-    while (!stack.empty())
-    {
+    while (!stack.empty()) {
         int act = stack.top();
         stack.pop();
 
-        if (checked[act] == GREY)
-        {
+        if (checked[act] == GREY) {
             cout << act << ' ';
-            for (auto it = lista[act].begin(); it != lista[act].end(); ++it)
-            {
+            for (auto it = lista[act].begin(); it != lista[act].end(); ++it) {
                 stack.push(*it);
                 if (checked[*it] != BLACK)
                     checked[*it] = GREY;
             }
-            checked[act] = BLACK; //nodo controllato
+            checked[act] = BLACK;  // nodo controllato
         }
     }
 }
 
-int main()
-{
+int main() {
     int u, w;
     int n;
     cin >> n;
     list<int> lista[INF];
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         cin >> u >> w;
         lista[u].push_back(w);
     }
diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index f25510935..650f0cd51 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -6,8 +6,7 @@ using namespace std;
 #define INF 10000010
 vector<pair<int, int>> graph[5 * 100001];
 int dis[5 * 100001];
-int dij(vector<pair<int, int>> *v, int s, int *dis)
-{
+int dij(vector<pair<int, int>> *v, int s, int *dis) {
     priority_queue<pair<int, int>, vector<pair<int, int>>,
                    greater<pair<int, int>>>
         pq;
@@ -15,28 +14,23 @@ int dij(vector<pair<int, int>> *v, int s, int *dis)
     pq.push(make_pair(0, s));
     dis[s] = 0;
     int u;
-    while (!pq.empty())
-    {
+    while (!pq.empty()) {
         u = (pq.top()).second;
         pq.pop();
         for (vector<pair<int, int>>::iterator it = v[u].begin();
-             it != v[u].end(); it++)
-        {
-            if (dis[u] + it->first < dis[it->second])
-            {
+             it != v[u].end(); it++) {
+            if (dis[u] + it->first < dis[it->second]) {
                 dis[it->second] = dis[u] + it->first;
                 pq.push(make_pair(dis[it->second], it->second));
             }
         }
     }
 }
-int main()
-{
+int main() {
     int m, n, l, x, y, s;
     // n--> number of nodes , m --> number of edges
     cin >> n >> m;
-    for (int i = 0; i < m; i++)
-    {
+    for (int i = 0; i < m; i++) {
         // input edges.
         scanf("%d%d%d", &x, &y, &l);
         graph[x].push_back(make_pair(l, y));
diff --git a/graph/kosaraju.cpp b/graph/kosaraju.cpp
index 0efa291bc..00c9d7ca0 100644
--- a/graph/kosaraju.cpp
+++ b/graph/kosaraju.cpp
@@ -13,10 +13,8 @@ using namespace std;
  * @param V : vertices
  * @return void
  **/
-void print(vector<int> a[], int V)
-{
-    for (int i = 0; i < V; i++)
-    {
+void print(vector<int> a[], int V) {
+    for (int i = 0; i < V; i++) {
         if (!a[i].empty())
             cout << "i=" << i << "-->";
         for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
@@ -33,11 +31,9 @@ void print(vector<int> a[], int V)
  * @param adj[] : array of vectors to represent graph
  * @return void
  **/
-void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[])
-{
+void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[]) {
     vis[v] = true;
-    for (auto i = adj[v].begin(); i != adj[v].end(); i++)
-    {
+    for (auto i = adj[v].begin(); i != adj[v].end(); i++) {
         if (vis[*i] == false)
             push_vertex(*i, st, vis, adj);
     }
@@ -51,12 +47,10 @@ void push_vertex(int v, stack<int> &st, bool vis[], vector<int> adj[])
  * @param grev[] : graph with reversed edges
  * @return void
  **/
-void dfs(int v, bool vis[], vector<int> grev[])
-{
+void dfs(int v, bool vis[], vector<int> grev[]) {
     vis[v] = true;
     // cout<<v<<" ";
-    for (auto i = grev[v].begin(); i != grev[v].end(); i++)
-    {
+    for (auto i = grev[v].begin(); i != grev[v].end(); i++) {
         if (vis[*i] == false)
             dfs(*i, vis, grev);
     }
@@ -72,21 +66,17 @@ no SCCs i.e. none(0) or there will be x no. of SCCs (x>0)) i.e. it returns the
 count of (number of) strongly connected components (SCCs) in the graph.
 (variable 'count_scc' within function)
 **/
-int kosaraju(int V, vector<int> adj[])
-{
+int kosaraju(int V, vector<int> adj[]) {
     bool vis[V] = {};
     stack<int> st;
-    for (int v = 0; v < V; v++)
-    {
+    for (int v = 0; v < V; v++) {
         if (vis[v] == false)
             push_vertex(v, st, vis, adj);
     }
     // making new graph (grev) with reverse edges as in adj[]:
     vector<int> grev[V];
-    for (int i = 0; i < V + 1; i++)
-    {
-        for (auto j = adj[i].begin(); j != adj[i].end(); j++)
-        {
+    for (int i = 0; i < V + 1; i++) {
+        for (auto j = adj[i].begin(); j != adj[i].end(); j++) {
             grev[*j].push_back(i);
         }
     }
@@ -95,12 +85,10 @@ int kosaraju(int V, vector<int> adj[])
     // reinitialise visited to 0
     for (int i = 0; i < V; i++) vis[i] = false;
     int count_scc = 0;
-    while (!st.empty())
-    {
+    while (!st.empty()) {
         int t = st.top();
         st.pop();
-        if (vis[t] == false)
-        {
+        if (vis[t] == false) {
             dfs(t, vis, grev);
             count_scc++;
         }
@@ -112,12 +100,10 @@ int kosaraju(int V, vector<int> adj[])
 
 // All critical/corner cases have been taken care of.
 // Input your required values: (not hardcoded)
-int main()
-{
+int main() {
     int t;
     cin >> t;
-    while (t--)
-    {
+    while (t--) {
         int a, b;  // a->number of nodes, b->directed edges.
         cin >> a >> b;
         int m, n;
diff --git a/graph/kruskal.cpp b/graph/kruskal.cpp
index 6bffd5cd9..b7b830668 100644
--- a/graph/kruskal.cpp
+++ b/graph/kruskal.cpp
@@ -24,47 +24,39 @@ typedef long long ll;
     cin.tie(NULL);                    \
     cout.tie(NULL);
 using namespace std;
-void in(int &x)
-{
+void in(int &x) {
     register int c = gc();
     x = 0;
     int neg = 0;
     for (; ((c < 48 || c > 57) && c != '-'); c = gc())
         ;
-    if (c == '-')
-    {
+    if (c == '-') {
         neg = 1;
         c = gc();
     }
-    for (; c > 47 && c < 58; c = gc())
-    {
+    for (; c > 47 && c < 58; c = gc()) {
         x = (x << 1) + (x << 3) + c - 48;
     }
     if (neg)
         x = -x;
 }
-void out(int n)
-{
+void out(int n) {
     int N = n, rev, count = 0;
     rev = N;
-    if (N == 0)
-    {
+    if (N == 0) {
         pc('0');
         return;
     }
-    while ((rev % 10) == 0)
-    {
+    while ((rev % 10) == 0) {
         count++;
         rev /= 10;
     }
     rev = 0;
-    while (N != 0)
-    {
+    while (N != 0) {
         rev = (rev << 3) + (rev << 1) + N % 10;
         N /= 10;
     }
-    while (rev != 0)
-    {
+    while (rev != 0) {
         pc(rev % 10 + '0');
         rev /= 10;
     }
@@ -72,53 +64,43 @@ void out(int n)
 }
 ll parent[mx], arr[mx], node, edge;
 vector<pair<ll, pair<ll, ll>>> v;
-void initial()
-{
+void initial() {
     int i;
     rep(i, node + edge) parent[i] = i;
 }
-int root(int i)
-{
-    while (parent[i] != i)
-    {
+int root(int i) {
+    while (parent[i] != i) {
         parent[i] = parent[parent[i]];
         i = parent[i];
     }
     return i;
 }
-void join(int x, int y)
-{
+void join(int x, int y) {
     int root_x = root(x);  // Disjoint set union by rank
     int root_y = root(y);
     parent[root_x] = root_y;
 }
-ll kruskal()
-{
+ll kruskal() {
     ll mincost = 0, i, x, y;
-    rep(i, edge)
-    {
+    rep(i, edge) {
         x = v[i].second.first;
         y = v[i].second.second;
-        if (root(x) != root(y))
-        {
+        if (root(x) != root(y)) {
             mincost += v[i].first;
             join(x, y);
         }
     }
     return mincost;
 }
-int main()
-{
+int main() {
     fast;
-    while (1)
-    {
+    while (1) {
         int i, j, from, to, cost, totalcost = 0;
         cin >> node >> edge;  // Enter the nodes and edges
         if (node == 0 && edge == 0)
             break;  // Enter 0 0 to break out
         initial();  // Initialise the parent array
-        rep(i, edge)
-        {
+        rep(i, edge) {
             cin >> from >> to >> cost;
             v.pb(mp(cost, mp(from, to)));
             totalcost += cost;
diff --git a/graph/lca.cpp b/graph/lca.cpp
index 743fb31ed..c05cf7b9b 100644
--- a/graph/lca.cpp
+++ b/graph/lca.cpp
@@ -7,19 +7,16 @@ using namespace std;
 // Resource : https://cp-algorithms.com/graph/lca_binary_lifting.html
 const int N = 1005;
 const int LG = log2(N) + 1;
-struct lca
-{
+struct lca {
     int n;
     vector<int> adj[N];  // Graph
     int up[LG][N];       // build this table
     int level[N];        // get the levels of all of them
 
-    lca(int n_) : n(n_)
-    {
+    lca(int n_) : n(n_) {
         memset(up, -1, sizeof(up));
         memset(level, 0, sizeof(level));
-        for (int i = 0; i < n - 1; ++i)
-        {
+        for (int i = 0; i < n - 1; ++i) {
             int a, b;
             cin >> a >> b;
             a--;
@@ -31,77 +28,59 @@ struct lca
         dfs(0, -1);
         build();
     }
-    void verify()
-    {
-        for (int i = 0; i < n; ++i)
-        {
+    void verify() {
+        for (int i = 0; i < n; ++i) {
             cout << i << " : level: " << level[i] << endl;
         }
         cout << endl;
-        for (int i = 0; i < LG; ++i)
-        {
+        for (int i = 0; i < LG; ++i) {
             cout << "Power:" << i << ": ";
-            for (int j = 0; j < n; ++j)
-            {
+            for (int j = 0; j < n; ++j) {
                 cout << up[i][j] << " ";
             }
             cout << endl;
         }
     }
 
-    void build()
-    {
-        for (int i = 1; i < LG; ++i)
-        {
-            for (int j = 0; j < n; ++j)
-            {
-                if (up[i - 1][j] != -1)
-                {
+    void build() {
+        for (int i = 1; i < LG; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (up[i - 1][j] != -1) {
                     up[i][j] = up[i - 1][up[i - 1][j]];
                 }
             }
         }
     }
 
-    void dfs(int node, int par)
-    {
+    void dfs(int node, int par) {
         up[0][node] = par;
-        for (auto i : adj[node])
-        {
-            if (i != par)
-            {
+        for (auto i : adj[node]) {
+            if (i != par) {
                 level[i] = level[node] + 1;
                 dfs(i, node);
             }
         }
     }
-    int query(int u, int v)
-    {
+    int query(int u, int v) {
         u--;
         v--;
-        if (level[v] > level[u])
-        {
+        if (level[v] > level[u]) {
             swap(u, v);
         }
         // u is at the bottom.
         int dist = level[u] - level[v];
         // Go up this much distance
-        for (int i = LG - 1; i >= 0; --i)
-        {
-            if (dist & (1 << i))
-            {
+        for (int i = LG - 1; i >= 0; --i) {
+            if (dist & (1 << i)) {
                 u = up[i][u];
             }
         }
-        if (u == v)
-        {
+        if (u == v) {
             return u;
         }
         assert(level[u] == level[v]);
-        for (int i = LG - 1; i >= 0; --i)
-        {
-            if (up[i][u] != up[i][v])
-            {
+        for (int i = LG - 1; i >= 0; --i) {
+            if (up[i][u] != up[i][v]) {
                 u = up[i][u];
                 v = up[i][v];
             }
@@ -111,8 +90,7 @@ struct lca
     }
 };
 
-int main()
-{
+int main() {
     int n;     // number of nodes in the tree.
     lca l(n);  // will take the input in the format given
     // n-1 edges of the form
diff --git a/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp b/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
index f02a48e01..cbd6bc15c 100644
--- a/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
+++ b/graph/max_flow_with_ford_fulkerson_and_edmond_karp_algo.cpp
@@ -15,8 +15,7 @@
 #include <vector>
 // std::max capacity of node in graph
 const int MAXN = 505;
-class Graph
-{
+class Graph {
     int residual_capacity[MAXN][MAXN];
     int capacity[MAXN][MAXN];  //  used while checking the flow of edge
     int total_nodes;
@@ -25,26 +24,21 @@ class Graph
     std::vector<std::tuple<int, int, int> > edge_participated;
     std::bitset<MAXN> visited;
     int max_flow = 0;
-    bool bfs(int source, int sink)
-    {  //  to find the augmented - path
+    bool bfs(int source, int sink) {  //  to find the augmented - path
         memset(parent, -1, sizeof(parent));
         visited.reset();
         std::queue<int> q;
         q.push(source);
         bool is_path_found = false;
-        while (q.empty() == false && is_path_found == false)
-        {
+        while (q.empty() == false && is_path_found == false) {
             int current_node = q.front();
             visited.set(current_node);
             q.pop();
-            for (int i = 0; i < total_nodes; ++i)
-            {
-                if (residual_capacity[current_node][i] > 0 && !visited[i])
-                {
+            for (int i = 0; i < total_nodes; ++i) {
+                if (residual_capacity[current_node][i] > 0 && !visited[i]) {
                     visited.set(i);
                     parent[i] = current_node;
-                    if (i == sink)
-                    {
+                    if (i == sink) {
                         return true;
                     }
                     q.push(i);
@@ -56,32 +50,26 @@ class Graph
 
  public:
     Graph() { memset(residual_capacity, 0, sizeof(residual_capacity)); }
-    void set_graph(void)
-    {
+    void set_graph(void) {
         std::cin >> total_nodes >> total_edges >> source >> sink;
-        for (int start, destination, capacity_, i = 0; i < total_edges; ++i)
-        {
+        for (int start, destination, capacity_, i = 0; i < total_edges; ++i) {
             std::cin >> start >> destination >> capacity_;
             residual_capacity[start][destination] = capacity_;
             capacity[start][destination] = capacity_;
         }
     }
-    void ford_fulkerson(void)
-    {
-        while (bfs(source, sink))
-        {
+    void ford_fulkerson(void) {
+        while (bfs(source, sink)) {
             int current_node = sink;
             int flow = std::numeric_limits<int>::max();
-            while (current_node != source)
-            {
+            while (current_node != source) {
                 int parent_ = parent[current_node];
                 flow = std::min(flow, residual_capacity[parent_][current_node]);
                 current_node = parent_;
             }
             current_node = sink;
             max_flow += flow;
-            while (current_node != source)
-            {
+            while (current_node != source) {
                 int parent_ = parent[current_node];
                 residual_capacity[parent_][current_node] -= flow;
                 residual_capacity[current_node][parent_] += flow;
@@ -89,14 +77,11 @@ class Graph
             }
         }
     }
-    void print_flow_info(void)
-    {
-        for (int i = 0; i < total_nodes; ++i)
-        {
-            for (int j = 0; j < total_nodes; ++j)
-            {
-                if (capacity[i][j] && residual_capacity[i][j] < capacity[i][j])
-                {
+    void print_flow_info(void) {
+        for (int i = 0; i < total_nodes; ++i) {
+            for (int j = 0; j < total_nodes; ++j) {
+                if (capacity[i][j] &&
+                    residual_capacity[i][j] < capacity[i][j]) {
                     edge_participated.push_back(std::make_tuple(
                         i, j, capacity[i][j] - residual_capacity[i][j]));
                 }
@@ -106,8 +91,7 @@ class Graph
                   << "\nEdge present in flow: " << edge_participated.size()
                   << '\n';
         std::cout << "\nSource\tDestination\tCapacity\total_nodes";
-        for (auto& edge_data : edge_participated)
-        {
+        for (auto& edge_data : edge_participated) {
             int source, destination, capacity_;
             std::tie(source, destination, capacity_) = edge_data;
             std::cout << source << "\t" << destination << "\t\t" << capacity_
@@ -115,8 +99,7 @@ class Graph
         }
     }
 };
-int main(void)
-{
+int main(void) {
     /*
        Input Graph: (for testing )
         4 5 0 3
diff --git a/graph/prim.cpp b/graph/prim.cpp
index 8332bdb36..5cc70bd39 100644
--- a/graph/prim.cpp
+++ b/graph/prim.cpp
@@ -9,8 +9,7 @@ typedef std::pair<int, int> PII;
 bool marked[MAX];
 std::vector<PII> adj[MAX];
 
-int prim(int x)
-{
+int prim(int x) {
     // priority queue to maintain edges with respect to weights
     std::priority_queue<PII, std::vector<PII>, std::greater<PII> > Q;
     int y;
@@ -18,8 +17,7 @@ int prim(int x)
     PII p;
 
     Q.push(std::make_pair(0, x));
-    while (!Q.empty())
-    {
+    while (!Q.empty()) {
         // Select the edge with minimum weight
         p = Q.top();
         Q.pop();
@@ -29,8 +27,7 @@ int prim(int x)
             continue;
         minimumCost += p.first;
         marked[x] = true;
-        for (int i = 0; i < adj[x].size(); ++i)
-        {
+        for (int i = 0; i < adj[x].size(); ++i) {
             y = adj[x][i].second;
             if (marked[y] == false)
                 Q.push(adj[x][i]);
@@ -39,8 +36,7 @@ int prim(int x)
     return minimumCost;
 }
 
-int main()
-{
+int main() {
     int nodes, edges, x, y;
     int weight, minimumCost;
 
@@ -49,8 +45,7 @@ int main()
         return 0;
 
     // Edges with their nodes & weight
-    for (int i = 0; i < edges; ++i)
-    {
+    for (int i = 0; i < edges; ++i) {
         std::cin >> x >> y >> weight;
         adj[x].push_back(std::make_pair(weight, y));
         adj[y].push_back(std::make_pair(weight, x));
diff --git a/graph/topological_sort.cpp b/graph/topological_sort.cpp
index d863c6993..9e6c8917b 100644
--- a/graph/topological_sort.cpp
+++ b/graph/topological_sort.cpp
@@ -8,44 +8,37 @@ vector<vector<int>> G;
 vector<bool> visited;
 vector<int> ans;
 
-void dfs(int v)
-{
+void dfs(int v) {
     visited[v] = true;
-    for (int u : G[v])
-    {
+    for (int u : G[v]) {
         if (!visited[u])
             dfs(u);
     }
     ans.push_back(v);
 }
 
-void topological_sort()
-{
+void topological_sort() {
     visited.assign(n, false);
     ans.clear();
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         if (!visited[i])
             dfs(i);
     }
     reverse(ans.begin(), ans.end());
 }
-int main()
-{
+int main() {
     cout << "Enter the number of vertices and the number of directed edges\n";
     cin >> n >> m;
     int x, y;
     G.resize(n, vector<int>());
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         cin >> x >> y;
         x--, y--;  // to convert 1-indexed to 0-indexed
         G[x].push_back(y);
     }
     topological_sort();
     cout << "Topological Order : \n";
-    for (int v : ans)
-    {
+    for (int v : ans) {
         cout << v + 1
              << ' ';  // converting zero based indexing back to one based.
     }
diff --git a/graph/topological_sort_by_kahns_algo.cpp b/graph/topological_sort_by_kahns_algo.cpp
index b56ae5651..57ee01b23 100644
--- a/graph/topological_sort_by_kahns_algo.cpp
+++ b/graph/topological_sort_by_kahns_algo.cpp
@@ -6,8 +6,7 @@
 
 int *topoSortKahn(int N, std::vector<int> adj[]);
 
-int main()
-{
+int main() {
     int nodes, edges;
     std::cin >> edges >> nodes;
     if (edges == 0 || nodes == 0)
@@ -20,36 +19,29 @@ int main()
     // 6 6
     // 5 0 5 2 2 3 4 0 4 1 1 3
 
-    for (int i = 0; i < edges; i++)
-    {
+    for (int i = 0; i < edges; i++) {
         std::cin >> u >> v;
         graph[u].push_back(v);
     }
 
     int *topo = topoSortKahn(nodes, graph);
     // topologically sorted nodes
-    for (int i = 0; i < nodes; i++)
-    {
+    for (int i = 0; i < nodes; i++) {
         std::cout << topo[i] << " ";
     }
 }
 
-int *topoSortKahn(int V, std::vector<int> adj[])
-{
+int *topoSortKahn(int V, std::vector<int> adj[]) {
     std::vector<bool> vis(V + 1, false);
     std::vector<int> deg(V + 1, 0);
-    for (int i = 0; i < V; i++)
-    {
-        for (int j = 0; j < adj[i].size(); j++)
-        {
+    for (int i = 0; i < V; i++) {
+        for (int j = 0; j < adj[i].size(); j++) {
             deg[adj[i][j]]++;
         }
     }
     std::queue<int> q;
-    for (int i = 0; i < V; i++)
-    {
-        if (deg[i] == 0)
-        {
+    for (int i = 0; i < V; i++) {
+        if (deg[i] == 0) {
             q.push(i);
             vis[i] = true;
         }
@@ -57,19 +49,15 @@ int *topoSortKahn(int V, std::vector<int> adj[])
     int *arr = new int[V + 1];
     memset(arr, 0, V + 1);
     int count = 0;
-    while (!q.empty())
-    {
+    while (!q.empty()) {
         int cur = q.front();
         q.pop();
         arr[count] = cur;
         count++;
-        for (int i = 0; i < adj[cur].size(); i++)
-        {
-            if (!vis[adj[cur][i]])
-            {
+        for (int i = 0; i < adj[cur].size(); i++) {
+            if (!vis[adj[cur][i]]) {
                 deg[adj[cur][i]]--;
-                if (deg[adj[cur][i]] == 0)
-                {
+                if (deg[adj[cur][i]] == 0) {
                     q.push(adj[cur][i]);
                     vis[adj[cur][i]] = true;
                 }
diff --git a/greedy_algorithms/dijkstra.cpp b/greedy_algorithms/dijkstra.cpp
index b87b4ab10..e4450379c 100644
--- a/greedy_algorithms/dijkstra.cpp
+++ b/greedy_algorithms/dijkstra.cpp
@@ -4,27 +4,22 @@
 using namespace std;
 
 // Wrapper class for storing a graph
-class Graph
-{
+class Graph {
  public:
     int vertexNum;
     int **edges;
 
     // Constructs a graph with V vertices and E edges
-    Graph(const int V)
-    {
+    Graph(const int V) {
         // initializes the array edges.
         this->edges = new int *[V];
-        for (int i = 0; i < V; i++)
-        {
+        for (int i = 0; i < V; i++) {
             edges[i] = new int[V];
         }
 
         // fills the array with zeros.
-        for (int i = 0; i < V; i++)
-        {
-            for (int j = 0; j < V; j++)
-            {
+        for (int i = 0; i < V; i++) {
+            for (int j = 0; j < V; j++) {
                 edges[i][j] = 0;
             }
         }
@@ -33,19 +28,15 @@ class Graph
     }
 
     // Adds the given edge to the graph
-    void addEdge(int src, int dst, int weight)
-    {
+    void addEdge(int src, int dst, int weight) {
         this->edges[src][dst] = weight;
     }
 };
 // Utility function to find minimum distance vertex in mdist
-int minDistance(int mdist[], bool vset[], int V)
-{
+int minDistance(int mdist[], bool vset[], int V) {
     int minVal = INT_MAX, minInd = 0;
-    for (int i = 0; i < V; i++)
-    {
-        if (!vset[i] && (mdist[i] < minVal))
-        {
+    for (int i = 0; i < V; i++) {
+        if (!vset[i] && (mdist[i] < minVal)) {
             minVal = mdist[i];
             minInd = i;
         }
@@ -55,11 +46,9 @@ int minDistance(int mdist[], bool vset[], int V)
 }
 
 // Utility function to print distances
-void print(int dist[], int V)
-{
+void print(int dist[], int V) {
     cout << "\nVertex  Distance" << endl;
-    for (int i = 0; i < V; i++)
-    {
+    for (int i = 0; i < V; i++) {
         if (dist[i] < INT_MAX)
             cout << i << "\t" << dist[i] << endl;
         else
@@ -70,16 +59,14 @@ void print(int dist[], int V)
 // The main function that finds the shortest path from given source
 // to all other vertices using Dijkstra's Algorithm.It doesn't work on negative
 // weights
-void Dijkstra(Graph graph, int src)
-{
+void Dijkstra(Graph graph, int src) {
     int V = graph.vertexNum;
     int mdist[V];  // Stores updated distances to vertex
     bool vset[V];  // vset[i] is true if the vertex i included
     // in the shortest path tree
 
     // Initialise mdist and vset. Set distance of source as zero
-    for (int i = 0; i < V; i++)
-    {
+    for (int i = 0; i < V; i++) {
         mdist[i] = INT_MAX;
         vset[i] = false;
     }
@@ -87,17 +74,14 @@ void Dijkstra(Graph graph, int src)
     mdist[src] = 0;
 
     // iterate to find shortest path
-    for (int count = 0; count < V - 1; count++)
-    {
+    for (int count = 0; count < V - 1; count++) {
         int u = minDistance(mdist, vset, V);
 
         vset[u] = true;
 
-        for (int v = 0; v < V; v++)
-        {
+        for (int v = 0; v < V; v++) {
             if (!vset[v] && graph.edges[u][v] &&
-                mdist[u] + graph.edges[u][v] < mdist[v])
-            {
+                mdist[u] + graph.edges[u][v] < mdist[v]) {
                 mdist[v] = mdist[u] + graph.edges[u][v];
             }
         }
@@ -107,8 +91,7 @@ void Dijkstra(Graph graph, int src)
 }
 
 // Driver Function
-int main()
-{
+int main() {
     int V, E, gsrc;
     int src, dst, weight;
     cout << "Enter number of vertices: ";
@@ -116,8 +99,7 @@ int main()
     cout << "Enter number of edges: ";
     cin >> E;
     Graph G(V);
-    for (int i = 0; i < E; i++)
-    {
+    for (int i = 0; i < E; i++) {
         cout << "\nEdge " << i + 1 << "\nEnter source: ";
         cin >> src;
         cout << "Enter destination: ";
@@ -126,12 +108,9 @@ int main()
         cin >> weight;
 
         // makes sure source and destionation are in the proper bounds.
-        if (src >= 0 && src < V && dst >= 0 && dst < V)
-        {
+        if (src >= 0 && src < V && dst >= 0 && dst < V) {
             G.addEdge(src, dst, weight);
-        }
-        else
-        {
+        } else {
             cout << "source and/or destination out of bounds" << endl;
             i--;
             continue;
diff --git a/greedy_algorithms/huffman.cpp b/greedy_algorithms/huffman.cpp
index bf3d9ff9a..21c8295f3 100644
--- a/greedy_algorithms/huffman.cpp
+++ b/greedy_algorithms/huffman.cpp
@@ -4,8 +4,7 @@
 using namespace std;
 
 // A Huffman tree node
-struct MinHeapNode
-{
+struct MinHeapNode {
     // One of the input characters
     char data;
 
@@ -26,8 +25,7 @@ struct MinHeapNode
 
 // For comparison of
 // two heap nodes (needed in min heap)
-struct compare
-{
+struct compare {
     bool operator()(MinHeapNode* l, MinHeapNode* r)
 
     {
@@ -37,8 +35,7 @@ struct compare
 
 // Prints huffman codes from
 // the root of Huffman Tree.
-void printCodes(struct MinHeapNode* root, string str)
-{
+void printCodes(struct MinHeapNode* root, string str) {
     if (!root)
         return;
 
@@ -51,8 +48,7 @@ void printCodes(struct MinHeapNode* root, string str)
 
 // The main function that builds a Huffman Tree and
 // print codes by traversing the built Huffman Tree
-void HuffmanCodes(char data[], int freq[], int size)
-{
+void HuffmanCodes(char data[], int freq[], int size) {
     struct MinHeapNode *left, *right, *top;
 
     // Create a min heap & inserts all characters of data[]
@@ -62,8 +58,7 @@ void HuffmanCodes(char data[], int freq[], int size)
         minHeap.push(new MinHeapNode(data[i], freq[i]));
 
     // Iterate while size of heap doesn't become 1
-    while (minHeap.size() != 1)
-    {
+    while (minHeap.size() != 1) {
         // Extract the two minimum
         // freq items from min heap
         left = minHeap.top();
@@ -93,8 +88,7 @@ void HuffmanCodes(char data[], int freq[], int size)
 }
 
 // Driver program to test above functions
-int main()
-{
+int main() {
     char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
     int freq[] = {5, 9, 12, 13, 16, 45};
 
diff --git a/greedy_algorithms/knapsack.cpp b/greedy_algorithms/knapsack.cpp
index 81fd879de..74be4fee0 100644
--- a/greedy_algorithms/knapsack.cpp
+++ b/greedy_algorithms/knapsack.cpp
@@ -1,25 +1,21 @@
 #include <iostream>
 using namespace std;
 
-struct Item
-{
+struct Item {
     int weight;
     int profit;
 };
 
 float profitPerUnit(Item x) { return (float)x.profit / (float)x.weight; }
 
-int partition(Item arr[], int low, int high)
-{
+int partition(Item arr[], int low, int high) {
     Item pivot = arr[high];  // pivot
     int i = (low - 1);       // Index of smaller element
 
-    for (int j = low; j < high; j++)
-    {
+    for (int j = low; j < high; j++) {
         // If current element is smaller than or
         // equal to pivot
-        if (profitPerUnit(arr[j]) <= profitPerUnit(pivot))
-        {
+        if (profitPerUnit(arr[j]) <= profitPerUnit(pivot)) {
             i++;  // increment index of smaller element
             Item temp = arr[i];
             arr[i] = arr[j];
@@ -32,10 +28,8 @@ int partition(Item arr[], int low, int high)
     return (i + 1);
 }
 
-void quickSort(Item arr[], int low, int high)
-{
-    if (low < high)
-    {
+void quickSort(Item arr[], int low, int high) {
+    if (low < high) {
         int p = partition(arr, low, high);
 
         quickSort(arr, low, p - 1);
@@ -43,8 +37,7 @@ void quickSort(Item arr[], int low, int high)
     }
 }
 
-int main()
-{
+int main() {
     cout << "\nEnter the capacity of the knapsack : ";
     float capacity;
     cin >> capacity;
@@ -52,8 +45,7 @@ int main()
     int n;
     cin >> n;
     Item itemArray[n];
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         cout << "\nEnter the weight and profit of item " << i + 1 << " : ";
         cin >> itemArray[i].weight;
         cin >> itemArray[i].profit;
@@ -65,17 +57,13 @@ int main()
 
     float maxProfit = 0;
     int i = n;
-    while (capacity > 0 && --i >= 0)
-    {
-        if (capacity >= itemArray[i].weight)
-        {
+    while (capacity > 0 && --i >= 0) {
+        if (capacity >= itemArray[i].weight) {
             maxProfit += itemArray[i].profit;
             capacity -= itemArray[i].weight;
             cout << "\n\t" << itemArray[i].weight << "\t"
                  << itemArray[i].profit;
-        }
-        else
-        {
+        } else {
             maxProfit += profitPerUnit(itemArray[i]) * capacity;
             cout << "\n\t" << capacity << "\t"
                  << profitPerUnit(itemArray[i]) * capacity;
diff --git a/greedy_algorithms/kruskals_minimum_spanning_tree.cpp b/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
index feeaf0102..9f35e86ac 100644
--- a/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
+++ b/greedy_algorithms/kruskals_minimum_spanning_tree.cpp
@@ -11,16 +11,12 @@ int graph[V][V] = {{0, 4, 1, 4, INFINITY, INFINITY},
                    {INFINITY, 3, 1, 5, 0, INFINITY},
                    {INFINITY, INFINITY, INFINITY, 7, INFINITY, 0}};
 
-void findMinimumEdge()
-{
-    for (int i = 0; i < V; i++)
-    {
+void findMinimumEdge() {
+    for (int i = 0; i < V; i++) {
         int min = INFINITY;
         int minIndex = 0;
-        for (int j = 0; j < V; j++)
-        {
-            if (graph[i][j] != 0 && graph[i][j] < min)
-            {
+        for (int j = 0; j < V; j++) {
+            if (graph[i][j] != 0 && graph[i][j] < min) {
                 min = graph[i][j];
                 minIndex = j;
             }
@@ -29,8 +25,7 @@ void findMinimumEdge()
     }
 }
 
-int main()
-{
+int main() {
     findMinimumEdge();
     return 0;
 }
diff --git a/greedy_algorithms/prims_minimum_spanning_tree.cpp b/greedy_algorithms/prims_minimum_spanning_tree.cpp
index c1d3df669..c804c176d 100644
--- a/greedy_algorithms/prims_minimum_spanning_tree.cpp
+++ b/greedy_algorithms/prims_minimum_spanning_tree.cpp
@@ -6,8 +6,7 @@ using namespace std;
 
 int graph[V][V] = {{0, 5, 1, 2}, {5, 0, 3, 3}, {1, 3, 0, 4}, {2, 3, 4, 0}};
 
-struct mst
-{
+struct mst {
     bool visited;
     int key;
     int near;
@@ -15,10 +14,8 @@ struct mst
 
 mst MST_Array[V];
 
-void initilize()
-{
-    for (int i = 0; i < V; i++)
-    {
+void initilize() {
+    for (int i = 0; i < V; i++) {
         MST_Array[i].visited = false;
         MST_Array[i].key = INFINITY;  // considering INFINITY as inifinity
         MST_Array[i].near = i;
@@ -27,17 +24,13 @@ void initilize()
     MST_Array[0].key = 0;
 }
 
-void updateNear()
-{
-    for (int v = 0; v < V; v++)
-    {
+void updateNear() {
+    for (int v = 0; v < V; v++) {
         int min = INFINITY;
         int minIndex = 0;
-        for (int i = 0; i < V; i++)
-        {
+        for (int i = 0; i < V; i++) {
             if (MST_Array[i].key < min && MST_Array[i].visited == false &&
-                MST_Array[i].key != INFINITY)
-            {
+                MST_Array[i].key != INFINITY) {
                 min = MST_Array[i].key;
                 minIndex = i;
             }
@@ -45,12 +38,9 @@ void updateNear()
 
         MST_Array[minIndex].visited = true;
 
-        for (int i = 0; i < V; i++)
-        {
-            if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY)
-            {
-                if (graph[minIndex][i] < MST_Array[i].key)
-                {
+        for (int i = 0; i < V; i++) {
+            if (graph[minIndex][i] != 0 && graph[minIndex][i] < INFINITY) {
+                if (graph[minIndex][i] < MST_Array[i].key) {
                     MST_Array[i].key = graph[minIndex][i];
                     MST_Array[i].near = minIndex;
                 }
@@ -59,17 +49,14 @@ void updateNear()
     }
 }
 
-void show()
-{
-    for (int i = 0; i < V; i++)
-    {
+void show() {
+    for (int i = 0; i < V; i++) {
         cout << i << "  -  " << MST_Array[i].near << "\t"
              << graph[i][MST_Array[i].near] << "\n";
     }
 }
 
-int main()
-{
+int main() {
     initilize();
     updateNear();
     show();
diff --git a/hashing/chaining.cpp b/hashing/chaining.cpp
index ae46aea59..6afd2d13b 100644
--- a/hashing/chaining.cpp
+++ b/hashing/chaining.cpp
@@ -2,51 +2,39 @@
 #include <iostream>
 using namespace std;
 
-struct Node
-{
+struct Node {
     int data;
     struct Node *next;
 } * head[100], *curr;
 
-void init()
-{
+void init() {
     for (int i = 0; i < 100; i++) head[i] = NULL;
 }
 
-void add(int x, int h)
-{
+void add(int x, int h) {
     struct Node *temp = new Node;
     temp->data = x;
     temp->next = NULL;
-    if (!head[h])
-    {
+    if (!head[h]) {
         head[h] = temp;
         curr = head[h];
-    }
-    else
-    {
+    } else {
         curr = head[h];
         while (curr->next) curr = curr->next;
         curr->next = temp;
     }
 }
 
-void display(int mod)
-{
+void display(int mod) {
     struct Node *temp;
     int i;
-    for (i = 0; i < mod; i++)
-    {
-        if (!head[i])
-        {
+    for (i = 0; i < mod; i++) {
+        if (!head[i]) {
             cout << "Key " << i << " is empty" << endl;
-        }
-        else
-        {
+        } else {
             cout << "Key " << i << " has values = ";
             temp = head[i];
-            while (temp->next)
-            {
+            while (temp->next) {
                 cout << temp->data << " ";
                 temp = temp->next;
             }
@@ -58,19 +46,16 @@ void display(int mod)
 
 int hash(int x, int mod) { return x % mod; }
 
-void find(int x, int h)
-{
+void find(int x, int h) {
     struct Node *temp = head[h];
-    if (!head[h])
-    {
+    if (!head[h]) {
         cout << "Element not found";
         return;
     }
     while (temp->data != x && temp->next) temp = temp->next;
     if (temp->next)
         cout << "Element found";
-    else
-    {
+    else {
         if (temp->data == x)
             cout << "Element found";
         else
@@ -78,15 +63,13 @@ void find(int x, int h)
     }
 }
 
-int main(void)
-{
+int main(void) {
     init();
     int c, x, mod, h;
     cout << "Enter the size of Hash Table. = ";
     cin >> mod;
     bool loop = true;
-    while (loop)
-    {
+    while (loop) {
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
         cout << "1. Add element." << endl;
@@ -95,8 +78,7 @@ int main(void)
         cout << "4. Display Hash table." << endl;
         cout << "5. Exit." << endl;
         cin >> c;
-        switch (c)
-        {
+        switch (c) {
         case 1:
             cout << "Enter element to add = ";
             cin >> x;
diff --git a/hashing/double_hash_hash_table.cpp b/hashing/double_hash_hash_table.cpp
index 842f383c5..7ee2757de 100644
--- a/hashing/double_hash_hash_table.cpp
+++ b/hashing/double_hash_hash_table.cpp
@@ -25,55 +25,44 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry
-{
+struct Entry {
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key)
-{
+int hashFxn(int key) {
     std::hash<int> hash;
     return hash(key);
 }
 
 // Used for second hash function
-int otherHashFxn(int key)
-{
+int otherHashFxn(int key) {
     std::hash<int> hash;
     return 1 + (7 - (hash(key) % 7));
 }
 
 // Performs double hashing to resolve collisions
-int doubleHash(int key, bool searching)
-{
+int doubleHash(int key, bool searching) {
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do
-    {
+    do {
         int index = static_cast<int>(fabs((hash + (i * otherHashFxn(key))))) %
                     totalSize;
         entry = table[index];
-        if (searching)
-        {
-            if (entry.key == notPresent)
-            {
+        if (searching) {
+            if (entry.key == notPresent) {
                 return notPresent;
             }
-            if (searchingProber(entry, key))
-            {
+            if (searchingProber(entry, key)) {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        }
-        else
-        {
-            if (putProber(entry, key))
-            {
+        } else {
+            if (putProber(entry, key)) {
                 if (!rehashing)
                     cout << "Spot found!" << endl;
                 return index;
@@ -87,8 +76,7 @@ int doubleHash(int key, bool searching)
                      << ")" << endl;
             i++;
         }
-        if (i == totalSize * 100)
-        {
+        if (i == totalSize * 100) {
             cout << "DoubleHash probe failed" << endl;
             return notPresent;
         }
@@ -97,38 +85,28 @@ int doubleHash(int key, bool searching)
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key)
-{
-    if (entry.key == notPresent || entry.key == tomb)
-    {
+bool putProber(Entry entry, int key) {
+    if (entry.key == notPresent || entry.key == tomb) {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key)
-{
+bool searchingProber(Entry entry, int key) {
     if (entry.key == key)
         return true;
     return false;
 }
 
 // Displays the table
-void display()
-{
-    for (int i = 0; i < totalSize; i++)
-    {
-        if (table[i].key == notPresent)
-        {
+void display() {
+    for (int i = 0; i < totalSize; i++) {
+        if (table[i].key == notPresent) {
             cout << " Empty ";
-        }
-        else if (table[i].key == tomb)
-        {
+        } else if (table[i].key == tomb) {
             cout << " Tomb ";
-        }
-        else
-        {
+        } else {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -138,8 +116,7 @@ void display()
 }
 
 // Rehashes the table into a bigger table
-void rehash()
-{
+void rehash() {
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -147,10 +124,8 @@ void rehash()
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++)
-    {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
-        {
+    for (int i = 0; i < oldSize; i++) {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -161,25 +136,21 @@ void rehash()
 }
 
 // Checks for load factor here
-void add(int key)
-{
+void add(int key) {
     Entry* entry = new Entry();
     entry->key = key;
     int index = doubleHash(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size / static_cast<double>(totalSize) >= 0.5)
-    {
+    if (++size / static_cast<double>(totalSize) >= 0.5) {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key)
-{
+void remove(int key) {
     int index = doubleHash(key, true);
-    if (index == notPresent)
-    {
+    if (index == notPresent) {
         cout << "key not found" << endl;
     }
     table[index].key = tomb;
@@ -188,8 +159,7 @@ void remove(int key)
 }
 
 // Information about the adding process
-void addInfo(int key)
-{
+void addInfo(int key) {
     cout << "Initial table: ";
     display();
     cout << endl;
@@ -202,8 +172,7 @@ void addInfo(int key)
 }
 
 // Information about removal process
-void removalInfo(int key)
-{
+void removalInfo(int key) {
     cout << "Initial table: ";
     display();
     cout << endl;
@@ -216,15 +185,13 @@ void removalInfo(int key)
 }
 
 // I/O
-int main(void)
-{
+int main(void) {
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop)
-    {
+    while (loop) {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -235,8 +202,7 @@ int main(void)
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd)
-        {
+        switch (cmd) {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -247,13 +213,11 @@ int main(void)
             cin >> key;
             removalInfo(key);
             break;
-        case 3:
-        {
+        case 3: {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[doubleHash(key, true)];
-            if (entry.key == notPresent)
-            {
+            if (entry.key == notPresent) {
                 cout << "Key not present";
             }
             break;
diff --git a/hashing/linear_probing_hash_table.cpp b/hashing/linear_probing_hash_table.cpp
index 0d4b5b0e1..393504c1d 100644
--- a/hashing/linear_probing_hash_table.cpp
+++ b/hashing/linear_probing_hash_table.cpp
@@ -25,47 +25,37 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry
-{
+struct Entry {
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key)
-{
+int hashFxn(int key) {
     std::hash<int> hash;
     return hash(key);
 }
 
 // Performs linear probing to resolve collisions
-int linearProbe(int key, bool searching)
-{
+int linearProbe(int key, bool searching) {
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do
-    {
+    do {
         int index = static_cast<int>(fabs((hash + i) % totalSize));
         entry = table[index];
-        if (searching)
-        {
-            if (entry.key == notPresent)
-            {
+        if (searching) {
+            if (entry.key == notPresent) {
                 return notPresent;
             }
-            if (searchingProber(entry, key))
-            {
+            if (searchingProber(entry, key)) {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        }
-        else
-        {
-            if (putProber(entry, key))
-            {
+        } else {
+            if (putProber(entry, key)) {
                 if (!rehashing)
                     cout << "Spot found!" << endl;
                 return index;
@@ -74,8 +64,7 @@ int linearProbe(int key, bool searching)
                 cout << "Spot taken, looking at next" << endl;
             i++;
         }
-        if (i == totalSize)
-        {
+        if (i == totalSize) {
             cout << "Linear probe failed" << endl;
             return notPresent;
         }
@@ -84,38 +73,28 @@ int linearProbe(int key, bool searching)
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key)
-{
-    if (entry.key == notPresent || entry.key == tomb)
-    {
+bool putProber(Entry entry, int key) {
+    if (entry.key == notPresent || entry.key == tomb) {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key)
-{
+bool searchingProber(Entry entry, int key) {
     if (entry.key == key)
         return true;
     return false;
 }
 
 // Displays the table
-void display()
-{
-    for (int i = 0; i < totalSize; i++)
-    {
-        if (table[i].key == notPresent)
-        {
+void display() {
+    for (int i = 0; i < totalSize; i++) {
+        if (table[i].key == notPresent) {
             cout << " Empty ";
-        }
-        else if (table[i].key == tomb)
-        {
+        } else if (table[i].key == tomb) {
             cout << " Tomb ";
-        }
-        else
-        {
+        } else {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -125,8 +104,7 @@ void display()
 }
 
 // Rehashes the table into a bigger table
-void rehash()
-{
+void rehash() {
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -134,10 +112,8 @@ void rehash()
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++)
-    {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
-        {
+    for (int i = 0; i < oldSize; i++) {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -148,25 +124,21 @@ void rehash()
 }
 
 // Adds entry using linear probing. Checks for load factor here
-void add(int key)
-{
+void add(int key) {
     Entry* entry = new Entry();
     entry->key = key;
     int index = linearProbe(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size / static_cast<double>(totalSize) >= 0.5)
-    {
+    if (++size / static_cast<double>(totalSize) >= 0.5) {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key)
-{
+void remove(int key) {
     int index = linearProbe(key, true);
-    if (index == notPresent)
-    {
+    if (index == notPresent) {
         cout << "key not found" << endl;
     }
     cout << "Removal Successful, leaving tomb" << endl;
@@ -175,8 +147,7 @@ void remove(int key)
 }
 
 // Information about the adding process
-void addInfo(int key)
-{
+void addInfo(int key) {
     cout << "Initial table: ";
     display();
     cout << endl;
@@ -189,8 +160,7 @@ void addInfo(int key)
 }
 
 // Information about removal process
-void removalInfo(int key)
-{
+void removalInfo(int key) {
     cout << "Initial table: ";
     display();
     cout << endl;
@@ -203,15 +173,13 @@ void removalInfo(int key)
 }
 
 // I/O
-int main(void)
-{
+int main(void) {
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop)
-    {
+    while (loop) {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -222,8 +190,7 @@ int main(void)
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd)
-        {
+        switch (cmd) {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -234,13 +201,11 @@ int main(void)
             cin >> key;
             removalInfo(key);
             break;
-        case 3:
-        {
+        case 3: {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[linearProbe(key, true)];
-            if (entry.key == notPresent)
-            {
+            if (entry.key == notPresent) {
                 cout << "Key not present";
             }
             break;
diff --git a/hashing/quadratic_probing_hash_table.cpp b/hashing/quadratic_probing_hash_table.cpp
index b549d057d..971c2182d 100644
--- a/hashing/quadratic_probing_hash_table.cpp
+++ b/hashing/quadratic_probing_hash_table.cpp
@@ -26,54 +26,43 @@ int size;
 bool rehashing;
 
 // Node that holds key
-struct Entry
-{
+struct Entry {
     explicit Entry(int key = notPresent) : key(key) {}
     int key;
 };
 
 // Hash a key
-int hashFxn(int key)
-{
+int hashFxn(int key) {
     std::hash<int> hash;
     return hash(key);
 }
 
 // Performs quadratic probing to resolve collisions
-int quadraticProbe(int key, bool searching)
-{
+int quadraticProbe(int key, bool searching) {
     int hash = static_cast<int>(fabs(hashFxn(key)));
     int i = 0;
     Entry entry;
-    do
-    {
+    do {
         int index = std::round(fabs(
             (hash + static_cast<int>(std::round(std::pow(i, 2)))) % totalSize));
         entry = table[index];
-        if (searching)
-        {
-            if (entry.key == notPresent)
-            {
+        if (searching) {
+            if (entry.key == notPresent) {
                 return notPresent;
             }
-            if (searchingProber(entry, key))
-            {
+            if (searchingProber(entry, key)) {
                 cout << "Found key!" << endl;
                 return index;
             }
             cout << "Found tombstone or equal hash, checking next" << endl;
             i++;
-        }
-        else
-        {
-            if (putProber(entry, key))
-            {
+        } else {
+            if (putProber(entry, key)) {
                 if (!rehashing)
                     cout << "Spot found!" << endl;
                 return index;
             }
-            if (!rehashing)
-            {
+            if (!rehashing) {
                 cout << "Spot taken, looking at next (next index = "
                      << std::round(fabs((hash + static_cast<int>(std::round(
                                                     std::pow(i + 1, 2)))) %
@@ -82,8 +71,7 @@ int quadraticProbe(int key, bool searching)
             }
             i++;
         }
-        if (i == totalSize * 100)
-        {
+        if (i == totalSize * 100) {
             cout << "Quadratic probe failed (infinite loop)" << endl;
             return notPresent;
         }
@@ -92,26 +80,22 @@ int quadraticProbe(int key, bool searching)
 }
 
 // Finds empty spot
-bool putProber(Entry entry, int key)
-{
-    if (entry.key == notPresent || entry.key == tomb)
-    {
+bool putProber(Entry entry, int key) {
+    if (entry.key == notPresent || entry.key == tomb) {
         return true;
     }
     return false;
 }
 
 // Looks for a matching key
-bool searchingProber(Entry entry, int key)
-{
+bool searchingProber(Entry entry, int key) {
     if (entry.key == key)
         return true;
     return false;
 }
 
 // Helper
-Entry find(int key)
-{
+Entry find(int key) {
     int index = quadraticProbe(key, true);
     if (index == notPresent)
         return Entry();
@@ -119,20 +103,13 @@ Entry find(int key)
 }
 
 // Displays the table
-void display()
-{
-    for (int i = 0; i < totalSize; i++)
-    {
-        if (table[i].key == notPresent)
-        {
+void display() {
+    for (int i = 0; i < totalSize; i++) {
+        if (table[i].key == notPresent) {
             cout << " Empty ";
-        }
-        else if (table[i].key == tomb)
-        {
+        } else if (table[i].key == tomb) {
             cout << " Tomb ";
-        }
-        else
-        {
+        } else {
             cout << " ";
             cout << table[i].key;
             cout << " ";
@@ -142,8 +119,7 @@ void display()
 }
 
 // Rehashes the table into a bigger table
-void rehash()
-{
+void rehash() {
     // Necessary so wall of add info isn't printed all at once
     rehashing = true;
     int oldSize = totalSize;
@@ -151,10 +127,8 @@ void rehash()
     // Really this should use the next prime number greater than totalSize * 2
     table = new Entry[totalSize * 2];
     totalSize *= 2;
-    for (int i = 0; i < oldSize; i++)
-    {
-        if (oldTable[i].key != -1 && oldTable[i].key != notPresent)
-        {
+    for (int i = 0; i < oldSize; i++) {
+        if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
             size--;  // Size stays the same (add increments size)
             add(oldTable[i].key);
         }
@@ -165,25 +139,21 @@ void rehash()
 }
 
 // Checks for load factor here
-void add(int key)
-{
+void add(int key) {
     Entry* entry = new Entry();
     entry->key = key;
     int index = quadraticProbe(key, false);
     table[index] = *entry;
     // Load factor greater than 0.5 causes resizing
-    if (++size / static_cast<double>(totalSize) >= 0.5)
-    {
+    if (++size / static_cast<double>(totalSize) >= 0.5) {
         rehash();
     }
 }
 
 // Removes key. Leaves tombstone upon removal.
-void remove(int key)
-{
+void remove(int key) {
     int index = quadraticProbe(key, true);
-    if (index == notPresent)
-    {
+    if (index == notPresent) {
         cout << "key not found" << endl;
     }
     table[index].key = tomb;
@@ -192,8 +162,7 @@ void remove(int key)
 }
 
 // Information about the adding process
-void addInfo(int key)
-{
+void addInfo(int key) {
     cout << "Initial table: ";
     display();
     cout << endl;
@@ -206,8 +175,7 @@ void addInfo(int key)
 }
 
 // Information about removal process
-void removalInfo(int key)
-{
+void removalInfo(int key) {
     cout << "Initial table: ";
     display();
     cout << endl;
@@ -220,15 +188,13 @@ void removalInfo(int key)
 }
 
 // I/O
-int main(void)
-{
+int main(void) {
     int cmd, hash, key;
     cout << "Enter the initial size of Hash Table. = ";
     cin >> totalSize;
     table = new Entry[totalSize];
     bool loop = true;
-    while (loop)
-    {
+    while (loop) {
         system("pause");
         cout << endl;
         cout << "PLEASE CHOOSE -" << endl;
@@ -239,8 +205,7 @@ int main(void)
         cout << "5. Display Hash table." << endl;
         cout << "6. Exit." << endl;
         cin >> cmd;
-        switch (cmd)
-        {
+        switch (cmd) {
         case 1:
             cout << "Enter key to add = ";
             cin >> key;
@@ -251,13 +216,11 @@ int main(void)
             cin >> key;
             removalInfo(key);
             break;
-        case 3:
-        {
+        case 3: {
             cout << "Enter key to search = ";
             cin >> key;
             Entry entry = table[quadraticProbe(key, true)];
-            if (entry.key == notPresent)
-            {
+            if (entry.key == notPresent) {
                 cout << "Key not present";
             }
             break;
diff --git a/math/binary_exponent.cpp b/math/binary_exponent.cpp
index 7bf3a34a1..05e6f33f7 100644
--- a/math/binary_exponent.cpp
+++ b/math/binary_exponent.cpp
@@ -25,32 +25,24 @@
 
 /// Recursive function to calculate exponent in \f$O(\log(n))\f$ using binary
 /// exponent.
-int binExpo(int a, int b)
-{
-    if (b == 0)
-    {
+int binExpo(int a, int b) {
+    if (b == 0) {
         return 1;
     }
     int res = binExpo(a, b / 2);
-    if (b % 2)
-    {
+    if (b % 2) {
         return res * res * a;
-    }
-    else
-    {
+    } else {
         return res * res;
     }
 }
 
 /// Iterative function to calculate exponent in \f$O(\log(n))\f$ using binary
 /// exponent.
-int binExpo_alt(int a, int b)
-{
+int binExpo_alt(int a, int b) {
     int res = 1;
-    while (b > 0)
-    {
-        if (b % 2)
-        {
+    while (b > 0) {
+        if (b % 2) {
             res = res * a;
         }
         a = a * a;
@@ -60,21 +52,15 @@ int binExpo_alt(int a, int b)
 }
 
 /// Main function
-int main()
-{
+int main() {
     int a, b;
     /// Give two numbers a, b
     std::cin >> a >> b;
-    if (a == 0 && b == 0)
-    {
+    if (a == 0 && b == 0) {
         std::cout << "Math error" << std::endl;
-    }
-    else if (b < 0)
-    {
+    } else if (b < 0) {
         std::cout << "Exponent must be positive !!" << std::endl;
-    }
-    else
-    {
+    } else {
         int resRecurse = binExpo(a, b);
         /// int resIterate = binExpo_alt(a, b);
 
diff --git a/math/double_factorial.cpp b/math/double_factorial.cpp
index 4909ad489..8e5ffcefa 100644
--- a/math/double_factorial.cpp
+++ b/math/double_factorial.cpp
@@ -13,11 +13,9 @@
 
 /** Compute double factorial using iterative method
  */
-uint64_t double_factorial_iterative(uint64_t n)
-{
+uint64_t double_factorial_iterative(uint64_t n) {
     uint64_t res = 1;
-    for (uint64_t i = n;; i -= 2)
-    {
+    for (uint64_t i = n;; i -= 2) {
         if (i == 0 || i == 1)
             return res;
         res *= i;
@@ -28,16 +26,14 @@ uint64_t double_factorial_iterative(uint64_t n)
 /** Compute double factorial using resursive method.
  * <br/>Recursion can be costly for large numbers.
  */
-uint64_t double_factorial_recursive(uint64_t n)
-{
+uint64_t double_factorial_recursive(uint64_t n) {
     if (n <= 1)
         return 1;
     return n * double_factorial_recursive(n - 2);
 }
 
 /// main function
-int main()
-{
+int main() {
     uint64_t n;
     std::cin >> n;
     assert(n >= 0);
diff --git a/math/eulers_totient_function.cpp b/math/eulers_totient_function.cpp
index 283516b42..8283ab045 100644
--- a/math/eulers_totient_function.cpp
+++ b/math/eulers_totient_function.cpp
@@ -29,15 +29,11 @@
 
 /** Function to caculate Euler's totient phi
  */
-uint64_t phiFunction(uint64_t n)
-{
+uint64_t phiFunction(uint64_t n) {
     uint64_t result = n;
-    for (uint64_t i = 2; i * i <= n; i++)
-    {
-        if (n % i == 0)
-        {
-            while (n % i == 0)
-            {
+    for (uint64_t i = 2; i * i <= n; i++) {
+        if (n % i == 0) {
+            while (n % i == 0) {
                 n /= i;
             }
             result -= result / i;
@@ -49,15 +45,11 @@ uint64_t phiFunction(uint64_t n)
 }
 
 /// Main function
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     uint64_t n;
-    if (argc < 2)
-    {
+    if (argc < 2) {
         std::cout << "Enter the number: ";
-    }
-    else
-    {
+    } else {
         n = strtoull(argv[1], nullptr, 10);
     }
     std::cin >> n;
diff --git a/math/extended_euclid_algorithm.cpp b/math/extended_euclid_algorithm.cpp
index 8a79e0c78..9fdc9692e 100644
--- a/math/extended_euclid_algorithm.cpp
+++ b/math/extended_euclid_algorithm.cpp
@@ -21,8 +21,7 @@
  * @param[in] quotient  unsigned
  */
 template <typename T, typename T2>
-inline void update_step(T *r, T *r0, const T2 quotient)
-{
+inline void update_step(T *r, T *r0, const T2 quotient) {
     T temp = *r;
     *r = *r0 - (quotient * temp);
     *r0 = temp;
@@ -39,8 +38,7 @@ inline void update_step(T *r, T *r0, const T2 quotient)
  * @param[out] y signed
  */
 template <typename T1, typename T2>
-void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y)
-{
+void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y) {
     if (B > A)
         std::swap(A, B);  // Ensure that A >= B
 
@@ -48,8 +46,7 @@ void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y)
     T2 t = 1, t0 = 0;
     T1 r = B, r0 = A;
 
-    while (r != 0)
-    {
+    while (r != 0) {
         T1 quotient = r0 / r;
         update_step(&r, &r0, quotient);
         update_step(&s, &s0, quotient);
@@ -70,19 +67,15 @@ void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y)
  * @param[in,out] y signed
  */
 template <typename T, typename T2>
-void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y)
-{
+void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y) {
     if (B > A)
         std::swap(A, B);  // Ensure that A >= B
 
-    if (B == 0)
-    {
+    if (B == 0) {
         *GCD = A;
         *x = 1;
         *y = 0;
-    }
-    else
-    {
+    } else {
         extendedEuclid(B, A % B, GCD, x, y);
         T2 temp = *x;
         *x = *y;
@@ -91,8 +84,7 @@ void extendedEuclid(T A, T B, T *GCD, T2 *x, T2 *y)
 }
 
 /// Main function
-int main()
-{
+int main() {
     uint32_t a, b, gcd;
     int32_t x, y;
     std::cin >> a >> b;
diff --git a/math/factorial.cpp b/math/factorial.cpp
index 7f50544e2..353f0b16b 100644
--- a/math/factorial.cpp
+++ b/math/factorial.cpp
@@ -5,16 +5,14 @@
 #include <iostream>
 
 /** function to find factorial of given number */
-unsigned int factorial(unsigned int n)
-{
+unsigned int factorial(unsigned int n) {
     if (n == 0)
         return 1;
     return n * factorial(n - 1);
 }
 
 /** Main function */
-int main()
-{
+int main() {
     int num = 5;
     std::cout << "Factorial of " << num << " is " << factorial(num)
               << std::endl;
diff --git a/math/fast_power.cpp b/math/fast_power.cpp
index 8a0525ac1..c5621cd4e 100644
--- a/math/fast_power.cpp
+++ b/math/fast_power.cpp
@@ -23,8 +23,7 @@
  * algorithm implementation for \f$a^b\f$
  */
 template <typename T>
-double fast_power_recursive(T a, T b)
-{
+double fast_power_recursive(T a, T b) {
     // negative power. a^b = 1 / (a^-b)
     if (b < 0)
         return 1.0 / fast_power_recursive(a, -b);
@@ -48,15 +47,13 @@ double fast_power_recursive(T a, T b)
     It still calculates in \f$O(\log N)\f$
 */
 template <typename T>
-double fast_power_linear(T a, T b)
-{
+double fast_power_linear(T a, T b) {
     // negative power. a^b = 1 / (a^-b)
     if (b < 0)
         return 1.0 / fast_power_linear(a, -b);
 
     double result = 1;
-    while (b)
-    {
+    while (b) {
         if (b & 1)
             result = result * a;
         a = a * a;
@@ -68,14 +65,12 @@ double fast_power_linear(T a, T b)
 /**
  * Main function
  */
-int main()
-{
+int main() {
     std::srand(std::time(nullptr));
     std::ios_base::sync_with_stdio(false);
 
     std::cout << "Testing..." << std::endl;
-    for (int i = 0; i < 20; i++)
-    {
+    for (int i = 0; i < 20; i++) {
         int a = std::rand() % 20 - 10;
         int b = std::rand() % 20 - 10;
         std::cout << std::endl << "Calculating " << a << "^" << b << std::endl;
diff --git a/math/fibonacci.cpp b/math/fibonacci.cpp
index 5a219bbf9..e15cfc0cc 100644
--- a/math/fibonacci.cpp
+++ b/math/fibonacci.cpp
@@ -14,8 +14,7 @@
 /**
  * Recursively compute sequences
  */
-int fibonacci(unsigned int n)
-{
+int fibonacci(unsigned int n) {
     /* If the input is 0 or 1 just return the same
        This will set the first 2 values of the sequence */
     if (n <= 1)
@@ -26,8 +25,7 @@ int fibonacci(unsigned int n)
 }
 
 /// Main function
-int main()
-{
+int main() {
     int n;
     std::cin >> n;
     assert(n >= 0);
diff --git a/math/fibonacci_fast.cpp b/math/fibonacci_fast.cpp
index 3b3a3ca38..08cced351 100644
--- a/math/fibonacci_fast.cpp
+++ b/math/fibonacci_fast.cpp
@@ -26,8 +26,7 @@ const uint64_t MAX = 93;
 uint64_t f[MAX] = {0};
 
 /** Algorithm */
-uint64_t fib(uint64_t n)
-{
+uint64_t fib(uint64_t n) {
     if (n == 0)
         return 0;
     if (n == 1 || n == 2)
@@ -44,11 +43,9 @@ uint64_t fib(uint64_t n)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     // Main Function
-    for (uint64_t i = 1; i < 93; i++)
-    {
+    for (uint64_t i = 1; i < 93; i++) {
         std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
     }
     return 0;
diff --git a/math/fibonacci_large.cpp b/math/fibonacci_large.cpp
index edc513750..d9dbff799 100644
--- a/math/fibonacci_large.cpp
+++ b/math/fibonacci_large.cpp
@@ -20,13 +20,11 @@
  * \f[f(n)=f(n-1)+f(n-2)\f]
  * and returns the result as a large_number type.
  */
-large_number fib(uint64_t n)
-{
+large_number fib(uint64_t n) {
     large_number f0(1);
     large_number f1(1);
 
-    do
-    {
+    do {
         large_number f2 = f1;
         f1 += f0;
         f0 = f2;
@@ -36,15 +34,11 @@ large_number fib(uint64_t n)
     return f1;
 }
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     uint64_t N;
-    if (argc == 2)
-    {
+    if (argc == 2) {
         N = strtoull(argv[1], NULL, 10);
-    }
-    else
-    {
+    } else {
         std::cout << "Enter N: ";
         std::cin >> N;
     }
diff --git a/math/gcd_iterative_euclidean.cpp b/math/gcd_iterative_euclidean.cpp
index e832605d7..2c0651ad7 100644
--- a/math/gcd_iterative_euclidean.cpp
+++ b/math/gcd_iterative_euclidean.cpp
@@ -12,34 +12,27 @@
 /**
  * algorithm
  */
-int gcd(int num1, int num2)
-{
-    if (num1 <= 0 | num2 <= 0)
-    {
+int gcd(int num1, int num2) {
+    if (num1 <= 0 | num2 <= 0) {
         throw std::domain_error("Euclidean algorithm domain is for ints > 0");
     }
 
-    if (num1 == num2)
-    {
+    if (num1 == num2) {
         return num1;
     }
 
     int base_num = 0;
     int previous_remainder = 1;
 
-    if (num1 > num2)
-    {
+    if (num1 > num2) {
         base_num = num1;
         previous_remainder = num2;
-    }
-    else
-    {
+    } else {
         base_num = num2;
         previous_remainder = num1;
     }
 
-    while ((base_num % previous_remainder) != 0)
-    {
+    while ((base_num % previous_remainder) != 0) {
         int old_base = base_num;
         base_num = previous_remainder;
         previous_remainder = old_base % previous_remainder;
@@ -51,15 +44,11 @@ int gcd(int num1, int num2)
 /**
  * Main function
  */
-int main()
-{
+int main() {
     std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
-    try
-    {
+    try {
         std::cout << "gcd of -120,10 is " << gcd(-120, 10) << std::endl;
-    }
-    catch (const std::domain_error &e)
-    {
+    } catch (const std::domain_error &e) {
         std::cout << "Error handling was successful" << std::endl;
     }
     std::cout << "gcd of 312,221 is " << (gcd(312, 221)) << std::endl;
diff --git a/math/gcd_of_n_numbers.cpp b/math/gcd_of_n_numbers.cpp
index cd81e6025..92968ff12 100644
--- a/math/gcd_of_n_numbers.cpp
+++ b/math/gcd_of_n_numbers.cpp
@@ -12,12 +12,10 @@
  * @param[in] a array of integers to compute GCD for
  * @param[in] n number of integers in array `a`
  */
-int gcd(int *a, int n)
-{
+int gcd(int *a, int n) {
     int j = 1;  // to access all elements of the array starting from 1
     int gcd = a[0];
-    while (j < n)
-    {
+    while (j < n) {
         if (a[j] % gcd == 0)  // value of gcd is as needed so far
             j++;              // so we check for next element
         else
@@ -27,8 +25,7 @@ int gcd(int *a, int n)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     int n;
     std::cout << "Enter value of n:" << std::endl;
     std::cin >> n;
diff --git a/math/gcd_recursive_euclidean.cpp b/math/gcd_recursive_euclidean.cpp
index d16fb1190..2a3d2183c 100644
--- a/math/gcd_recursive_euclidean.cpp
+++ b/math/gcd_recursive_euclidean.cpp
@@ -11,15 +11,12 @@
 /**
  * algorithm
  */
-int gcd(int num1, int num2)
-{
-    if (num1 <= 0 | num2 <= 0)
-    {
+int gcd(int num1, int num2) {
+    if (num1 <= 0 | num2 <= 0) {
         throw std::domain_error("Euclidean algorithm domain is for ints > 0");
     }
 
-    if (num1 == num2)
-    {
+    if (num1 == num2) {
         return num1;
     }
 
@@ -42,15 +39,11 @@ int gcd(int num1, int num2)
 /**
  * Main function
  */
-int main()
-{
+int main() {
     std::cout << "gcd of 120,7 is " << (gcd(120, 7)) << std::endl;
-    try
-    {
+    try {
         std::cout << "gcd of -120,10 is " << gcd(-120, 10) << std::endl;
-    }
-    catch (const std::domain_error &e)
-    {
+    } catch (const std::domain_error &e) {
         std::cout << "Error handling was successful" << std::endl;
     }
     std::cout << "gcd of 312,221 is " << (gcd(312, 221)) << std::endl;
diff --git a/math/large_factorial.cpp b/math/large_factorial.cpp
index 0a54f620b..1027f41ab 100644
--- a/math/large_factorial.cpp
+++ b/math/large_factorial.cpp
@@ -13,8 +13,7 @@
 /** Test implementation for 10! Result must be 3628800.
  * @returns True if test pass else False
  */
-bool test1()
-{
+bool test1() {
     std::cout << "---- Check 1\t";
     unsigned int i, number = 10;
     large_number result;
@@ -24,18 +23,15 @@ bool test1()
     const char *known_reslt = "3628800";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits())
-    {
+    if (strlen(known_reslt) != result.num_digits()) {
         std::cerr << "Result lengths dont match! " << strlen(known_reslt)
                   << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++)
-    {
-        if (known_reslt[i] != result.digit_char(i))
-        {
+    for (i = 0; i < N; i++) {
+        if (known_reslt[i] != result.digit_char(i)) {
             std::cerr << i << "^th digit mismatch! " << known_reslt[i]
                       << " != " << result.digit_char(i) << std::endl;
             return false;
@@ -54,8 +50,7 @@ bool test1()
  * ```
  * @returns True if test pass else False
  */
-bool test2()
-{
+bool test2() {
     std::cout << "---- Check 2\t";
     unsigned int i, number = 100;
     large_number result;
@@ -68,18 +63,15 @@ bool test2()
         "000000000000000000";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits())
-    {
+    if (strlen(known_reslt) != result.num_digits()) {
         std::cerr << "Result lengths dont match! " << strlen(known_reslt)
                   << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++)
-    {
-        if (known_reslt[i] != result.digit_char(i))
-        {
+    for (i = 0; i < N; i++) {
+        if (known_reslt[i] != result.digit_char(i)) {
             std::cerr << i << "^th digit mismatch! " << known_reslt[i]
                       << " != " << result.digit_char(i) << std::endl;
             return false;
@@ -93,16 +85,12 @@ bool test2()
 /**
  * Main program
  **/
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     int number, i;
 
-    if (argc == 2)
-    {
+    if (argc == 2) {
         number = atoi(argv[1]);
-    }
-    else
-    {
+    } else {
         std::cout << "Enter the value of n(n starts from 0 ): ";
         std::cin >> number;
     }
diff --git a/math/large_number.h b/math/large_number.h
index 88e3ba802..c1a3665e4 100644
--- a/math/large_number.h
+++ b/math/large_number.h
@@ -20,8 +20,7 @@
  * digit to the number, perform multiplication of
  * large number with long unsigned integers.
  **/
-class large_number
-{
+class large_number {
  public:
     /**< initializer with value = 1 */
     large_number() { _digits.push_back(1); }
@@ -36,11 +35,9 @@ class large_number
     // }
 
     /**< initializer from an integer */
-    explicit large_number(int n)
-    {
+    explicit large_number(int n) {
         int carry = n;
-        do
-        {
+        do {
             add_digit(carry % 10);
             carry /= 10;
         } while (carry != 0);
@@ -53,10 +50,8 @@ class large_number
     explicit large_number(std::vector<unsigned char> &vec) : _digits(vec) {}
 
     /**< initializer from a string */
-    explicit large_number(char const *number_str)
-    {
-        for (size_t i = strlen(number_str); i > 0; i--)
-        {
+    explicit large_number(char const *number_str) {
+        for (size_t i = strlen(number_str); i > 0; i--) {
             unsigned char a = number_str[i - 1] - '0';
             if (a >= 0 && a <= 9)
                 _digits.push_back(a);
@@ -66,55 +61,48 @@ class large_number
     /**
      * Function to check implementation
      **/
-    static bool test()
-    {
+    static bool test() {
         std::cout << "------ Checking `large_number` class implementations\t"
                   << std::endl;
         large_number a(40);
         // 1. test multiplication
         a *= 10;
-        if (a != large_number(400))
-        {
+        if (a != large_number(400)) {
             std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 1/6...";
         // 2. test compound addition with integer
         a += 120;
-        if (a != large_number(520))
-        {
+        if (a != large_number(520)) {
             std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 2/6...";
         // 3. test compound multiplication again
         a *= 10;
-        if (a != large_number(5200))
-        {
+        if (a != large_number(5200)) {
             std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 3/6...";
         // 4. test increment (prefix)
         ++a;
-        if (a != large_number(5201))
-        {
+        if (a != large_number(5201)) {
             std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 4/6...";
         // 5. test increment (postfix)
         a++;
-        if (a != large_number(5202))
-        {
+        if (a != large_number(5202)) {
             std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 5/6...";
         // 6. test addition with another large number
         a = a + large_number("7000000000000000000000000000000");
-        if (a != large_number("7000000000000000000000000005202"))
-        {
+        if (a != large_number("7000000000000000000000000005202")) {
             std::cerr << "\tFailed 6/6 (" << a
                       << "!=7000000000000000000000000005202)" << std::endl;
             return false;
@@ -126,10 +114,8 @@ class large_number
     /**
      * add a digit at MSB to the large number
      **/
-    void add_digit(unsigned int value)
-    {
-        if (value > 9)
-        {
+    void add_digit(unsigned int value) {
+        if (value > 9) {
             std::cerr << "digit > 9!!\n";
             exit(EXIT_FAILURE);
         }
@@ -149,16 +135,14 @@ class large_number
      **/
     inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
 
-    inline const unsigned char &operator[](size_t n) const
-    {
+    inline const unsigned char &operator[](size_t n) const {
         return this->_digits[n];
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend std::ostream &operator<<(std::ostream &out, const large_number &a)
-    {
+    friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
         for (size_t i = a.num_digits(); i > 0; i--)
             out << static_cast<int>(a[i - 1]);
         return out;
@@ -167,8 +151,7 @@ class large_number
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator==(large_number const &a, large_number const &b)
-    {
+    friend bool operator==(large_number const &a, large_number const &b) {
         size_t N = a.num_digits();
         if (N != b.num_digits())
             return false;
@@ -181,16 +164,14 @@ class large_number
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator!=(large_number const &a, large_number const &b)
-    {
+    friend bool operator!=(large_number const &a, large_number const &b) {
         return !(a == b);
     }
 
     /**
      * operator overload to increment (prefix)
      **/
-    large_number &operator++()
-    {
+    large_number &operator++() {
         (*this) += 1;
         return *this;
     }
@@ -198,8 +179,7 @@ class large_number
     /**
      * operator overload to increment (postfix)
      **/
-    large_number &operator++(int)
-    {
+    large_number &operator++(int) {
         static large_number tmp(_digits);
         ++(*this);
         return tmp;
@@ -208,15 +188,13 @@ class large_number
     /**
      * operator overload to add
      **/
-    large_number &operator+=(large_number n)
-    {
+    large_number &operator+=(large_number n) {
         // if adding with another large_number
         large_number *b = reinterpret_cast<large_number *>(&n);
         const size_t max_L = std::max(this->num_digits(), b->num_digits());
         unsigned int carry = 0;
         size_t i;
-        for (i = 0; i < max_L || carry != 0; i++)
-        {
+        for (i = 0; i < max_L || carry != 0; i++) {
             if (i < b->num_digits())
                 carry += (*b)[i];
             if (i < this->num_digits())
@@ -238,8 +216,7 @@ class large_number
      * operator overload to perform addition
      **/
     template <class T>
-    friend large_number &operator+(const large_number &a, const T &b)
-    {
+    friend large_number &operator+(const large_number &a, const T &b) {
         static large_number c = a;
         c += b;
         return c;
@@ -248,8 +225,7 @@ class large_number
     /**
      * assignment operator
      **/
-    large_number &operator=(const large_number &b)
-    {
+    large_number &operator=(const large_number &b) {
         this->_digits = b._digits;
         return *this;
     }
@@ -258,8 +234,7 @@ class large_number
      * operator overload to increment
      **/
     template <class T>
-    large_number &operator*=(const T n)
-    {
+    large_number &operator*=(const T n) {
         static_assert(std::is_integral<T>::value,
                       "Must be integer addition unsigned integer types.");
         this->multiply(n);
@@ -269,8 +244,7 @@ class large_number
     /**
      * returns i^th digit as an ASCII character
      **/
-    const char digit_char(size_t i) const
-    {
+    const char digit_char(size_t i) const {
         return _digits[num_digits() - i - 1] + '0';
     }
 
@@ -280,8 +254,7 @@ class large_number
      * store the result in the same large number
      **/
     template <class T>
-    void multiply(const T n)
-    {
+    void multiply(const T n) {
         static_assert(std::is_integral<T>::value,
                       "Can only have integer types.");
         // assert(!(std::is_signed<T>::value)); //, "Implemented only for
@@ -289,24 +262,19 @@ class large_number
 
         size_t i;
         uint64_t carry = 0, temp;
-        for (i = 0; i < this->num_digits(); i++)
-        {
+        for (i = 0; i < this->num_digits(); i++) {
             temp = (*this)[i] * n;
             temp += carry;
-            if (temp < 10)
-            {
+            if (temp < 10) {
                 carry = 0;
-            }
-            else
-            {
+            } else {
                 carry = temp / 10;
                 temp = temp % 10;
             }
             (*this)[i] = temp;
         }
 
-        while (carry != 0)
-        {
+        while (carry != 0) {
             this->add_digit(carry % 10);
             carry /= 10;
         }
diff --git a/math/modular_inverse_fermat_little_theorem.cpp b/math/modular_inverse_fermat_little_theorem.cpp
index 6895cafbb..7550e14bf 100644
--- a/math/modular_inverse_fermat_little_theorem.cpp
+++ b/math/modular_inverse_fermat_little_theorem.cpp
@@ -49,14 +49,11 @@
 /** Recursive function to calculate exponent in \f$O(\log n)\f$ using binary
  * exponent.
  */
-int64_t binExpo(int64_t a, int64_t b, int64_t m)
-{
+int64_t binExpo(int64_t a, int64_t b, int64_t m) {
     a %= m;
     int64_t res = 1;
-    while (b > 0)
-    {
-        if (b % 2)
-        {
+    while (b > 0) {
+        if (b % 2) {
             res = res * a % m;
         }
         a = a * a % m;
@@ -68,18 +65,12 @@ int64_t binExpo(int64_t a, int64_t b, int64_t m)
 
 /** Prime check in \f$O(\sqrt{m})\f$ time.
  */
-bool isPrime(int64_t m)
-{
-    if (m <= 1)
-    {
+bool isPrime(int64_t m) {
+    if (m <= 1) {
         return false;
-    }
-    else
-    {
-        for (int64_t i = 2; i * i <= m; i++)
-        {
-            if (m % i == 0)
-            {
+    } else {
+        for (int64_t i = 2; i * i <= m; i++) {
+            if (m % i == 0) {
                 return false;
             }
         }
@@ -90,21 +81,17 @@ bool isPrime(int64_t m)
 /**
  * Main function
  */
-int main()
-{
+int main() {
     int64_t a, m;
     // Take input of  a and m.
     std::cout << "Computing ((a^(-1))%(m)) using Fermat's Little Theorem";
     std::cout << std::endl << std::endl;
     std::cout << "Give input 'a' and 'm' space separated : ";
     std::cin >> a >> m;
-    if (isPrime(m))
-    {
+    if (isPrime(m)) {
         std::cout << "The modular inverse of a with mod m is (a^(m-2)) : ";
         std::cout << binExpo(a, m - 2, m) << std::endl;
-    }
-    else
-    {
+    } else {
         std::cout << "m must be a prime number.";
         std::cout << std::endl;
     }
diff --git a/math/number_of_positive_divisors.cpp b/math/number_of_positive_divisors.cpp
index beb459943..f157f7b41 100644
--- a/math/number_of_positive_divisors.cpp
+++ b/math/number_of_positive_divisors.cpp
@@ -31,31 +31,25 @@ respectively.
 /**
  * Algorithm
  */
-int number_of_positive_divisors(int n)
-{
+int number_of_positive_divisors(int n) {
     std::vector<int> prime_exponent_count;
-    for (int i = 2; i * i <= n; i++)
-    {
+    for (int i = 2; i * i <= n; i++) {
         int prime_count = 0;
-        while (n % i == 0)
-        {
+        while (n % i == 0) {
             prime_count += 1;
             n /= i;
         }
-        if (prime_count != 0)
-        {
+        if (prime_count != 0) {
             prime_exponent_count.push_back(prime_count);
         }
     }
-    if (n > 1)
-    {
+    if (n > 1) {
         prime_exponent_count.push_back(1);
     }
 
     int divisors_count = 1;
 
-    for (int i = 0; i < prime_exponent_count.size(); i++)
-    {
+    for (int i = 0; i < prime_exponent_count.size(); i++) {
         divisors_count = divisors_count * (prime_exponent_count[i] + 1);
     }
 
@@ -65,20 +59,15 @@ int number_of_positive_divisors(int n)
 /**
  * Main function
  */
-int main()
-{
+int main() {
     int n;
     std::cin >> n;
-    if (n < 0)
-    {
+    if (n < 0) {
         n = -n;
     }
-    if (n == 0)
-    {
+    if (n == 0) {
         std::cout << "All non-zero numbers are divisors of 0 !" << std::endl;
-    }
-    else
-    {
+    } else {
         std::cout << "Number of positive divisors is : ";
         std::cout << number_of_positive_divisors(n) << std::endl;
     }
diff --git a/math/power_for_huge_numbers.cpp b/math/power_for_huge_numbers.cpp
index 1f969f89d..301767d66 100644
--- a/math/power_for_huge_numbers.cpp
+++ b/math/power_for_huge_numbers.cpp
@@ -22,15 +22,13 @@
  * @param res large number representation using array
  * @param res_size number of digits in `res`
  */
-int multiply(int x, int res[], int res_size)
-{
+int multiply(int x, int res[], int res_size) {
     // Initialize carry
     int carry = 0;
 
     // One by one multiply n with
     // individual digits of res[]
-    for (int i = 0; i < res_size; i++)
-    {
+    for (int i = 0; i < res_size; i++) {
         int prod = res[i] * x + carry;
 
         // Store last digit of
@@ -43,8 +41,7 @@ int multiply(int x, int res[], int res_size)
 
     // Put carry in res and
     // increase result size
-    while (carry)
-    {
+    while (carry) {
         res[res_size] = carry % 10;
         carry = carry / 10;
         res_size++;
@@ -56,11 +53,9 @@ int multiply(int x, int res[], int res_size)
  * @param x base
  * @param n exponent
  */
-void power(int x, int n)
-{
+void power(int x, int n) {
     // printing value "1" for power = 0
-    if (n == 0)
-    {
+    if (n == 0) {
         std::cout << "1";
         return;
     }
@@ -70,8 +65,7 @@ void power(int x, int n)
     int temp = x;
 
     // Initialize result
-    while (temp != 0)
-    {
+    while (temp != 0) {
         res[res_size++] = temp % 10;
         temp = temp / 10;
     }
@@ -85,8 +79,7 @@ void power(int x, int n)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     int exponent, base;
     std::cout << "Enter base ";
     std::cin >> base;
diff --git a/math/prime_factorization.cpp b/math/prime_factorization.cpp
index c650497e2..001c2c3c3 100644
--- a/math/prime_factorization.cpp
+++ b/math/prime_factorization.cpp
@@ -20,43 +20,35 @@ std::vector<std::pair<int, int>> factors;
 
 /** Calculating prime number upto a given range
  */
-void SieveOfEratosthenes(int N)
-{
+void SieveOfEratosthenes(int N) {
     // initializes the array isprime
     memset(isprime, true, sizeof isprime);
 
-    for (int i = 2; i <= N; i++)
-    {
-        if (isprime[i])
-        {
+    for (int i = 2; i <= N; i++) {
+        if (isprime[i]) {
             for (int j = 2 * i; j <= N; j += i) isprime[j] = false;
         }
     }
 
-    for (int i = 2; i <= N; i++)
-    {
+    for (int i = 2; i <= N; i++) {
         if (isprime[i])
             prime_numbers.push_back(i);
     }
 }
 
 /** Prime factorization of a number */
-void prime_factorization(int num)
-{
+void prime_factorization(int num) {
     int number = num;
 
-    for (int i = 0; prime_numbers[i] <= num; i++)
-    {
+    for (int i = 0; prime_numbers[i] <= num; i++) {
         int count = 0;
 
         // termination condition
-        if (number == 1)
-        {
+        if (number == 1) {
             break;
         }
 
-        while (number % prime_numbers[i] == 0)
-        {
+        while (number % prime_numbers[i] == 0) {
             count++;
             number = number / prime_numbers[i];
         }
@@ -67,8 +59,7 @@ void prime_factorization(int num)
 }
 
 /** Main program */
-int main()
-{
+int main() {
     int num;
     std::cout << "\t\tComputes the prime factorization\n\n";
     std::cout << "Type in a number: ";
@@ -79,8 +70,7 @@ int main()
     prime_factorization(num);
 
     // Prime factors with their powers in the given number in new line
-    for (auto it : factors)
-    {
+    for (auto it : factors) {
         std::cout << it.first << " " << it.second << std::endl;
     }
 
diff --git a/math/prime_numbers.cpp b/math/prime_numbers.cpp
index b3a52a104..4dd54f136 100644
--- a/math/prime_numbers.cpp
+++ b/math/prime_numbers.cpp
@@ -9,15 +9,12 @@
 /** Generate an increasingly large number of primes
  * and store in a list
  */
-std::vector<int> primes(int max)
-{
+std::vector<int> primes(int max) {
     max++;
     std::vector<int> res;
     std::vector<bool> numbers(max, false);
-    for (int i = 2; i < max; i++)
-    {
-        if (!numbers[i])
-        {
+    for (int i = 2; i < max; i++) {
+        if (!numbers[i]) {
             for (int j = i; j < max; j += i) numbers[j] = true;
             res.push_back(i);
         }
@@ -26,8 +23,7 @@ std::vector<int> primes(int max)
 }
 
 /** main function */
-int main()
-{
+int main() {
     std::cout << "Calculate primes up to:\n>> ";
     int n;
     std::cin >> n;
diff --git a/math/primes_up_to_billion.cpp b/math/primes_up_to_billion.cpp
index 6c02b9089..4fb79a15e 100644
--- a/math/primes_up_to_billion.cpp
+++ b/math/primes_up_to_billion.cpp
@@ -10,15 +10,12 @@
 char prime[100000000];
 
 /** Perform Sieve algorithm */
-void Sieve(int64_t n)
-{
+void Sieve(int64_t n) {
     memset(prime, '1', sizeof(prime));  // intitize '1' to every index
     prime[0] = '0';                     // 0 is not prime
     prime[1] = '0';                     // 1 is not prime
-    for (int p = 2; p * p <= n; p++)
-    {
-        if (prime[p] == '1')
-        {
+    for (int p = 2; p * p <= n; p++) {
+        if (prime[p] == '1') {
             for (int i = p * p; i <= n; i += p)
                 prime[i] = '0';  // set all multiples of p to false
         }
@@ -26,8 +23,7 @@ void Sieve(int64_t n)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     Sieve(100000000);
     int64_t n;
     std::cin >> n;  // 10006187
diff --git a/math/sieve_of_eratosthenes.cpp b/math/sieve_of_eratosthenes.cpp
index 90ad8bc40..d8fa70531 100644
--- a/math/sieve_of_eratosthenes.cpp
+++ b/math/sieve_of_eratosthenes.cpp
@@ -22,16 +22,12 @@ bool isprime[MAX];
  * This is the function that finds the primes and eliminates
  * the multiples.
  */
-void sieve(uint32_t N)
-{
+void sieve(uint32_t N) {
     isprime[0] = false;
     isprime[1] = false;
-    for (uint32_t i = 2; i <= N; i++)
-    {
-        if (isprime[i])
-        {
-            for (uint32_t j = (i << 1); j <= N; j += i)
-            {
+    for (uint32_t i = 2; i <= N; i++) {
+        if (isprime[i]) {
+            for (uint32_t j = (i << 1); j <= N; j += i) {
                 isprime[j] = false;
             }
         }
@@ -41,12 +37,9 @@ void sieve(uint32_t N)
 /**
  * This function prints out the primes to STDOUT
  */
-void print(uint32_t N)
-{
-    for (uint32_t i = 1; i <= N; i++)
-    {
-        if (isprime[i])
-        {
+void print(uint32_t N) {
+    for (uint32_t i = 1; i <= N; i++) {
+        if (isprime[i]) {
             std::cout << i << ' ';
         }
     }
@@ -56,17 +49,14 @@ void print(uint32_t N)
 /**
  * Initialize the array
  */
-void init()
-{
-    for (uint32_t i = 1; i < MAX; i++)
-    {
+void init() {
+    for (uint32_t i = 1; i < MAX; i++) {
         isprime[i] = true;
     }
 }
 
 /** main function */
-int main()
-{
+int main() {
     uint32_t N = 100;
     init();
     sieve(N);
diff --git a/math/sqrt_double.cpp b/math/sqrt_double.cpp
index ffc83998a..1521b500a 100644
--- a/math/sqrt_double.cpp
+++ b/math/sqrt_double.cpp
@@ -13,10 +13,8 @@
 /** Bisection method implemented for the function \f$x^2-a=0\f$
  * whose roots are \f$\pm\sqrt{a}\f$ and only the positive root is returned.
  */
-double Sqrt(double a)
-{
-    if (a > 0 && a < 1)
-    {
+double Sqrt(double a) {
+    if (a > 0 && a < 1) {
         return 1 / Sqrt(1 / a);
     }
     double l = 0, r = a;
@@ -26,17 +24,12 @@ double Sqrt(double a)
     double epsilon = 1e-12;
     */
     double epsilon = 1e-12;
-    while (l <= r)
-    {
+    while (l <= r) {
         double mid = (l + r) / 2;
-        if (mid * mid > a)
-        {
+        if (mid * mid > a) {
             r = mid;
-        }
-        else
-        {
-            if (a - mid * mid < epsilon)
-            {
+        } else {
+            if (a - mid * mid < epsilon) {
                 return mid;
             }
             l = mid;
@@ -46,8 +39,7 @@ double Sqrt(double a)
 }
 
 /** main function */
-int main()
-{
+int main() {
     double n{};
     std::cin >> n;
     assert(n >= 0);
diff --git a/math/string_fibonacci.cpp b/math/string_fibonacci.cpp
index 401b04d2d..eb9b6d7e1 100644
--- a/math/string_fibonacci.cpp
+++ b/math/string_fibonacci.cpp
@@ -21,50 +21,41 @@
  * \param [in] b second number in string to add
  * \returns sum as a std::string
  */
-std::string add(std::string a, std::string b)
-{
+std::string add(std::string a, std::string b) {
     std::string temp = "";
 
     // carry flag
     int carry = 0;
 
     // fills up with zeros
-    while (a.length() < b.length())
-    {
+    while (a.length() < b.length()) {
         a = "0" + a;
     }
 
     // fills up with zeros
-    while (b.length() < a.length())
-    {
+    while (b.length() < a.length()) {
         b = "0" + b;
     }
 
     // adds the numbers a and b
-    for (int i = a.length() - 1; i >= 0; i--)
-    {
+    for (int i = a.length() - 1; i >= 0; i--) {
         char val = static_cast<char>(((a[i] - 48) + (b[i] - 48)) + 48 + carry);
-        if (val > 57)
-        {
+        if (val > 57) {
             carry = 1;
             val -= 10;
-        }
-        else
-        {
+        } else {
             carry = 0;
         }
         temp = val + temp;
     }
 
     // processes the carry flag
-    if (carry == 1)
-    {
+    if (carry == 1) {
         temp = "1" + temp;
     }
 
     // removes leading zeros.
-    while (temp[0] == '0' && temp.length() > 1)
-    {
+    while (temp[0] == '0' && temp.length() > 1) {
         temp = temp.substr(1);
     }
 
@@ -74,13 +65,11 @@ std::string add(std::string a, std::string b)
 /** Fibonacci iterator
  * \param [in] n n^th Fibonacci number
  */
-void fib_Accurate(uint64_t n)
-{
+void fib_Accurate(uint64_t n) {
     std::string tmp = "";
     std::string fibMinus1 = "1";
     std::string fibMinus2 = "0";
-    for (uint64_t i = 0; i < n; i++)
-    {
+    for (uint64_t i = 0; i < n; i++) {
         tmp = add(fibMinus1, fibMinus2);
         fibMinus2 = fibMinus1;
         fibMinus1 = tmp;
@@ -89,8 +78,7 @@ void fib_Accurate(uint64_t n)
 }
 
 /** main function */
-int main()
-{
+int main() {
     int n;
     std::cout << "Enter whatever number N you want to find the fibonacci of\n";
     std::cin >> n;
diff --git a/operations_on_datastructures/array_left_rotation.cpp b/operations_on_datastructures/array_left_rotation.cpp
index 444738360..7b8f7f279 100644
--- a/operations_on_datastructures/array_left_rotation.cpp
+++ b/operations_on_datastructures/array_left_rotation.cpp
@@ -1,7 +1,6 @@
 #include <iostream>
 using namespace std;
-int main()
-{
+int main() {
     int n, k;
     cout << "Enter size of array=\t";
     cin >> n;
@@ -9,29 +8,22 @@ int main()
     cin >> k;
     int a[n];
     cout << "Enter  elements of array=\t";
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         cin >> a[i];
     }
     int temp = 0;
-    for (int i = 0; i < k; i++)
-    {
+    for (int i = 0; i < k; i++) {
         temp = a[0];
-        for (int j = 0; j < n; j++)
-        {
-            if (j == n - 1)
-            {
+        for (int j = 0; j < n; j++) {
+            if (j == n - 1) {
                 a[n - 1] = temp;
-            }
-            else
-            {
+            } else {
                 a[j] = a[j + 1];
             }
         }
     }
     cout << "Your rotated array is=\t";
-    for (int j = 0; j < n; j++)
-    {
+    for (int j = 0; j < n; j++) {
         cout << a[j] << " ";
     }
     getchar();
diff --git a/operations_on_datastructures/array_right_rotation.cpp b/operations_on_datastructures/array_right_rotation.cpp
index 5077d2d74..8b01a2003 100644
--- a/operations_on_datastructures/array_right_rotation.cpp
+++ b/operations_on_datastructures/array_right_rotation.cpp
@@ -1,7 +1,6 @@
 #include <iostream>
 using namespace std;
-int main()
-{
+int main() {
     int n, k;
     cout << "Enter size of array=\t";
     cin >> n;
@@ -11,24 +10,18 @@ int main()
     cout << "Enter elements of array=\t";
     for (int i = 0; i < n; i++) cin >> a[i];
     int temp = 0;
-    for (int i = 0; i < k; i++)
-    {
+    for (int i = 0; i < k; i++) {
         temp = a[n - 1];
-        for (int j = n - 1; j >= 0; j--)
-        {
-            if (j == 0)
-            {
+        for (int j = n - 1; j >= 0; j--) {
+            if (j == 0) {
                 a[j] = temp;
-            }
-            else
-            {
+            } else {
                 a[j] = a[j - 1];
             }
         }
     }
     cout << "Your rotated array is=\t";
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         cout << a[i] << " ";
     }
 }
diff --git a/operations_on_datastructures/circular_linked_list.cpp b/operations_on_datastructures/circular_linked_list.cpp
index 2fddd3b7b..1119bb5e7 100644
--- a/operations_on_datastructures/circular_linked_list.cpp
+++ b/operations_on_datastructures/circular_linked_list.cpp
@@ -1,31 +1,25 @@
 #include <iostream>
 using namespace std;
 
-struct node
-{
+struct node {
     int val;
     node *next;
 };
 
 node *start;
 
-void insert(int x)
-{
+void insert(int x) {
     node *t = start;
 
-    if (start != NULL)
-    {
-        while (t->next != start)
-        {
+    if (start != NULL) {
+        while (t->next != start) {
             t = t->next;
         }
         node *n = new node;
         t->next = n;
         n->val = x;
         n->next = start;
-    }
-    else
-    {
+    } else {
         node *n = new node;
         n->val = x;
         start = n;
@@ -33,12 +27,10 @@ void insert(int x)
     }
 }
 
-void remove(int x)
-{
+void remove(int x) {
     node *t = start;
     node *p;
-    while (t->val != x)
-    {
+    while (t->val != x) {
         p = t;
         t = t->next;
     }
@@ -46,49 +38,40 @@ void remove(int x)
     delete t;
 }
 
-void search(int x)
-{
+void search(int x) {
     node *t = start;
     int found = 0;
-    while (t->next != start)
-    {
-        if (t->val == x)
-        {
+    while (t->next != start) {
+        if (t->val == x) {
             cout << "\nFound";
             found = 1;
             break;
         }
         t = t->next;
     }
-    if (found == 0)
-    {
+    if (found == 0) {
         cout << "\nNot Found";
     }
 }
 
-void show()
-{
+void show() {
     node *t = start;
-    do
-    {
+    do {
         cout << t->val << "\t";
         t = t->next;
     } while (t != start);
 }
 
-int main()
-{
+int main() {
     int choice, x;
-    do
-    {
+    do {
         cout << "\n1. Insert";
         cout << "\n2. Delete";
         cout << "\n3. Search";
         cout << "\n4. Print";
         cout << "\n\nEnter you choice : ";
         cin >> choice;
-        switch (choice)
-        {
+        switch (choice) {
         case 1:
             cout << "\nEnter the element to be inserted : ";
             cin >> x;
diff --git a/operations_on_datastructures/circular_queue_using_array.cpp b/operations_on_datastructures/circular_queue_using_array.cpp
index cf6e39dd5..e0e049611 100644
--- a/operations_on_datastructures/circular_queue_using_array.cpp
+++ b/operations_on_datastructures/circular_queue_using_array.cpp
@@ -6,65 +6,49 @@ int front = 0;
 int rear = 0;
 int count = 0;
 
-void Enque(int x)
-{
-    if (count == 10)
-    {
+void Enque(int x) {
+    if (count == 10) {
         cout << "\nOverflow";
-    }
-    else
-    {
+    } else {
         queue[rear] = x;
         rear = (rear + 1) % 10;
         count++;
     }
 }
 
-void Deque()
-{
-    if (front == rear)
-    {
+void Deque() {
+    if (front == rear) {
         cout << "\nUnderflow";
     }
 
-    else
-    {
+    else {
         cout << "\n" << queue[front] << " deleted";
         front = (front + 1) % 10;
         count--;
     }
 }
 
-void show()
-{
-    for (int i = 0; i < count; i++)
-    {
+void show() {
+    for (int i = 0; i < count; i++) {
         cout << queue[(i + front) % 10] << "\t";
     }
 }
 
-int main()
-{
+int main() {
     int ch, x;
-    do
-    {
+    do {
         cout << "\n1. Enque";
         cout << "\n2. Deque";
         cout << "\n3. Print";
         cout << "\nEnter Your Choice : ";
         cin >> ch;
-        if (ch == 1)
-        {
+        if (ch == 1) {
             cout << "\nInsert : ";
             cin >> x;
             Enque(x);
-        }
-        else if (ch == 2)
-        {
+        } else if (ch == 2) {
             Deque();
-        }
-        else if (ch == 3)
-        {
+        } else if (ch == 3) {
             show();
         }
     } while (ch != 0);
diff --git a/operations_on_datastructures/get_size_of_linked_list.cpp b/operations_on_datastructures/get_size_of_linked_list.cpp
index 0f22967c2..84f8db07f 100644
--- a/operations_on_datastructures/get_size_of_linked_list.cpp
+++ b/operations_on_datastructures/get_size_of_linked_list.cpp
@@ -1,7 +1,6 @@
 #include <iostream>
 
-class Node
-{
+class Node {
  public:
     int val;
     Node *next;
@@ -9,23 +8,19 @@ class Node
     Node(int v, Node *n) : val(v), next(n) {}  // Default constructor for Node
 };
 
-int getSize(Node *root)
-{
-    if (root == NULL)
-    {
+int getSize(Node *root) {
+    if (root == NULL) {
         return 0;
     }
     // Each node will return 1 so the total adds up to be the size
     return 1 + getSize(root->next);
 }
 
-int main()
-{
+int main() {
     Node *myList = new Node(0, NULL);  // Initializes the LinkedList
     Node *temp = myList;
     // Creates a linked lists of total size 10, numbered 1 - 10
-    for (int i = 1; i < 10; i++)
-    {
+    for (int i = 1; i < 10; i++) {
         temp->next = new Node(i, NULL);
         temp = temp->next;
     }
diff --git a/operations_on_datastructures/intersection_of_2_arrays.cpp b/operations_on_datastructures/intersection_of_2_arrays.cpp
index df83c9f21..8a3b27edf 100644
--- a/operations_on_datastructures/intersection_of_2_arrays.cpp
+++ b/operations_on_datastructures/intersection_of_2_arrays.cpp
@@ -1,6 +1,5 @@
 #include <iostream>
-int main()
-{
+int main() {
     int i, j, m, n;
     cout << "Enter size of array 1:";
     cin >> m;
@@ -13,14 +12,12 @@ int main()
     for (i = 0; i < n; i++) cin >> b[i];
     i = 0;
     j = 0;
-    while ((i < m) && (j < n))
-    {
+    while ((i < m) && (j < n)) {
         if (a[i] < b[j])
             i++;
         else if (a[i] > b[j])
             j++;
-        else
-        {
+        else {
             cout << a[i++] << " ";
             j++;
         }
diff --git a/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp b/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
index 4fe6d2915..b9540d951 100644
--- a/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
+++ b/operations_on_datastructures/reverse_a_linked_list_using_recusion.cpp
@@ -1,30 +1,24 @@
 #include <iostream>
 using namespace std;
 
-struct node
-{
+struct node {
     int val;
     node *next;
 };
 
 node *start;
 
-void insert(int x)
-{
+void insert(int x) {
     node *t = start;
-    if (start != NULL)
-    {
-        while (t->next != NULL)
-        {
+    if (start != NULL) {
+        while (t->next != NULL) {
             t = t->next;
         }
         node *n = new node;
         t->next = n;
         n->val = x;
         n->next = NULL;
-    }
-    else
-    {
+    } else {
         node *n = new node;
         n->val = x;
         n->next = NULL;
@@ -32,35 +26,28 @@ void insert(int x)
     }
 }
 
-void reverse(node *p, node *q)
-{
-    if (q->next == NULL)
-    {
+void reverse(node *p, node *q) {
+    if (q->next == NULL) {
         q->next = p;
         p->next = NULL;
         start = q;
         return;
-    }
-    else
-    {
+    } else {
         reverse(q, q->next);
         q->next = p;
         p->next = NULL;
     }
 }
 
-void show()
-{
+void show() {
     node *t = start;
-    while (t != NULL)
-    {
+    while (t != NULL) {
         cout << t->val << "\t";
         t = t->next;
     }
 }
 
-int main()
-{
+int main() {
     insert(1);
     insert(2);
     insert(3);
diff --git a/operations_on_datastructures/selectionsortlinkedlist.cpp b/operations_on_datastructures/selectionsortlinkedlist.cpp
index 550928d01..0e8e80def 100644
--- a/operations_on_datastructures/selectionsortlinkedlist.cpp
+++ b/operations_on_datastructures/selectionsortlinkedlist.cpp
@@ -2,24 +2,20 @@
 using namespace std;
 
 // node defined
-class node
-{
+class node {
  public:
     int data;
     node *link;
-    node(int d)
-    {
+    node(int d) {
         data = d;
         link = NULL;
     }
 };
 
 // printing the linked list
-void print(node *head)
-{
+void print(node *head) {
     node *current = head;
-    while (current != NULL)
-    {
+    while (current != NULL) {
         cout << current->data << " ";
         current = current->link;
     }
@@ -27,18 +23,15 @@ void print(node *head)
 }
 
 // creating the linked list with 'n' nodes
-node *createlist(int n)
-{
+node *createlist(int n) {
     node *head = NULL;
     node *t = NULL;
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         node *temp = NULL;
         int num;
         cin >> num;
         temp = new node(num);
-        if (head == NULL)
-        {
+        if (head == NULL) {
             head = temp;
             t = temp;
             continue;
@@ -51,8 +44,7 @@ node *createlist(int n)
 }
 
 // performing selection sort on the linked list in an iterative manner
-void my_selection_sort_linked_list(node *&head)
-{
+void my_selection_sort_linked_list(node *&head) {
     node *min = head;  // throughout the algorithm 'min' is used to denote the
                        // node with min value out of all the nodes left for
                        // scanning while scanning if we find a node 'X' with
@@ -61,7 +53,7 @@ void my_selection_sort_linked_list(node *&head)
     node *current =
         min->link;  // 'current' refers to the current node we are scanning
     node *previous = min;  //'previous' refers to the node that is previous to
-                           //the current node
+                           // the current node
     node *temp =
         NULL;  // 'temp' in this algo is used to point to the last node of the
                // sorted part of the linked list.
@@ -102,8 +94,8 @@ void my_selection_sort_linked_list(node *&head)
                         current->link = previous;
                         min = current;
                         current = previous->link;
-                    }
-                    else  // if the 'previous' is not pointing to the 'min' node
+                    } else  // if the 'previous' is not pointing to the 'min'
+                            // node
                     {
                         // Update the pointers
                         head = current;  // update the head pointer with the
@@ -113,8 +105,8 @@ void my_selection_sort_linked_list(node *&head)
                         min = current;
                         current = previous->link;
                     }
-                }
-                else  // if 'temp' is not NULL, i.e., its not the 1st iteration
+                } else  // if 'temp' is not NULL, i.e., its not the 1st
+                        // iteration
                 {
                     temp->link = current;
                     previous->link = current->link;
@@ -122,9 +114,8 @@ void my_selection_sort_linked_list(node *&head)
                     min = current;
                     current = previous->link;
                 }
-            }
-            else  // if the current node is greater than min, just move the
-                  // previous and the current pointer a step further
+            } else  // if the current node is greater than min, just move the
+                    // previous and the current pointer a step further
             {
                 previous = previous->link;
                 current = current->link;
@@ -132,8 +123,8 @@ void my_selection_sort_linked_list(node *&head)
         }
 
         // update the pointers. Set 'temp' to the last node in the sorted part.
-        // Make 'min' move a step further so that 'min' points to the 1st node of
-        // the unsorted part start the iteration again
+        // Make 'min' move a step further so that 'min' points to the 1st node
+        // of the unsorted part start the iteration again
         temp = min;
         min = min->link;
         previous = min;
@@ -163,8 +154,7 @@ void my_selection_sort_linked_list(node *&head)
 // original list is : 5 3 4 1 -2 -4
 // sorted list is : -4 -2 1 3 4 5
 
-int main()
-{
+int main() {
     node *head = NULL;
     int n;
     cout << "enter the no. of nodes : ";  // taking input from user about the
diff --git a/operations_on_datastructures/union_of_2_arrays.cpp b/operations_on_datastructures/union_of_2_arrays.cpp
index 45845f341..cdacf1d2e 100644
--- a/operations_on_datastructures/union_of_2_arrays.cpp
+++ b/operations_on_datastructures/union_of_2_arrays.cpp
@@ -1,6 +1,5 @@
 #include <iostream>
-int main()
-{
+int main() {
     int m, n, i = 0, j = 0;
     cout << "Enter size of both arrays:";
     cin >> m >> n;
@@ -12,14 +11,12 @@ int main()
     for (i = 0; i < n; i++) cin >> b[i];
     i = 0;
     j = 0;
-    while ((i < m) && (j < n))
-    {
+    while ((i < m) && (j < n)) {
         if (a[i] < b[j])
             cout << a[i++] << " ";
         else if (a[i] > b[j])
             cout << b[j++] << " ";
-        else
-        {
+        else {
             cout << a[i++];
             j++;
         }
diff --git a/others/buzz_number.cpp b/others/buzz_number.cpp
index 712b79401..ed9fc5f28 100644
--- a/others/buzz_number.cpp
+++ b/others/buzz_number.cpp
@@ -6,12 +6,10 @@
 #include <iostream>
 
 /** main function */
-int main()
-{
+int main() {
     int n, t;
     std::cin >> t;
-    while (t--)
-    {
+    while (t--) {
         std::cin >> n;
         if ((n % 7 == 0) || (n % 10 == 7))
             std::cout << n << " is a buzz number" << std::endl;
diff --git a/others/decimal_to_binary.cpp b/others/decimal_to_binary.cpp
index 32616944f..11ce064a5 100644
--- a/others/decimal_to_binary.cpp
+++ b/others/decimal_to_binary.cpp
@@ -8,12 +8,10 @@
  * This method converts the bit representation and stores it as a decimal
  * number.
  */
-void method1(int number)
-{
+void method1(int number) {
     int remainder, binary = 0, var = 1;
 
-    do
-    {
+    do {
         remainder = number % 2;
         number = number / 2;
         binary = binary + (remainder * var);
@@ -26,13 +24,11 @@ void method1(int number)
  * This method stores each bit value from LSB to MSB and then prints them back
  * from MSB to LSB
  */
-void method2(int number)
-{
+void method2(int number) {
     int num_bits = 0;
     char bit_string[50];
 
-    do
-    {
+    do {
         bool bit = number & 0x01;  // get last bit
         if (bit)
             bit_string[num_bits++] = '1';
@@ -47,8 +43,7 @@ void method2(int number)
     std::cout << std::endl;
 }
 
-int main()
-{
+int main() {
     int number;
     std::cout << "Enter a number:";
     std::cin >> number;
diff --git a/others/decimal_to_hexadecimal.cpp b/others/decimal_to_hexadecimal.cpp
index f0a521db6..a3e544f49 100644
--- a/others/decimal_to_hexadecimal.cpp
+++ b/others/decimal_to_hexadecimal.cpp
@@ -8,8 +8,7 @@
 /**
  * Main program
  */
-int main(void)
-{
+int main(void) {
     int valueToConvert = 0;  // Holds user input
     int hexArray[8];         // Contains hex values backwards
     int i = 0;               // counter
@@ -20,8 +19,7 @@ int main(void)
     std::cin >>
         valueToConvert;  // Stores value into valueToConvert via user input
 
-    while (valueToConvert > 15)
-    {                                         // Dec to Hex Algorithm
+    while (valueToConvert > 15) {             // Dec to Hex Algorithm
         hexArray[i++] = valueToConvert % 16;  // Gets remainder
         valueToConvert /= 16;
         // valueToConvert >>= 4;  // This will divide by 2^4=16 and is faster
diff --git a/others/decimal_to_roman_numeral.cpp b/others/decimal_to_roman_numeral.cpp
index fbcbaa232..ad4aa32c5 100644
--- a/others/decimal_to_roman_numeral.cpp
+++ b/others/decimal_to_roman_numeral.cpp
@@ -12,8 +12,7 @@
 /** This functions fills a string with character c, n times and returns it
  * @note This can probably be replace by `memcpy` function.
  */
-std::string fill(char c, int n)
-{
+std::string fill(char c, int n) {
     std::string s = "";
     while (n--) s += c;
     return s;
@@ -22,8 +21,7 @@ std::string fill(char c, int n)
 /** to convert to lowercase Roman Numeral
  * the function works recursively
  */
-std::string tolowerRoman(int n)
-{
+std::string tolowerRoman(int n) {
     if (n < 4)
         return fill('i', n);
     if (n < 6)
@@ -57,8 +55,7 @@ std::string tolowerRoman(int n)
 /** to convert to uppercase Roman Numeral
  * the function works recursively
  */
-std::string toupperRoman(int n)
-{
+std::string toupperRoman(int n) {
     if (n < 4)
         return fill('I', n);
     if (n < 6)
@@ -90,8 +87,7 @@ std::string toupperRoman(int n)
 }
 
 /** main function */
-int main()
-{
+int main() {
     int n;
     std::cout << "\t\tRoman numbers converter\n\n";
     std::cout << "Type in decimal number between 0 up to 4000 (exclusive): ";
diff --git a/others/fast_interger_input.cpp b/others/fast_interger_input.cpp
index a71e807dd..87963c9ad 100644
--- a/others/fast_interger_input.cpp
+++ b/others/fast_interger_input.cpp
@@ -8,8 +8,7 @@
 /** Function to read the number from stdin. The function reads input until a non
  * numeric character is entered.
  */
-void fastinput(int *number)
-{
+void fastinput(int *number) {
     // variable to indicate sign of input integer
     bool negative = false;
     register int c;
@@ -17,8 +16,7 @@ void fastinput(int *number)
 
     // extract current character from buffer
     c = std::getchar();
-    if (c == '-')
-    {
+    if (c == '-') {
         // number is negative
         negative = true;
 
@@ -38,8 +36,7 @@ void fastinput(int *number)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     int number;
     fastinput(&number);
     std::cout << number << std::endl;
diff --git a/others/happy_number.cpp b/others/happy_number.cpp
index 494891e3b..b1debaa54 100644
--- a/others/happy_number.cpp
+++ b/others/happy_number.cpp
@@ -11,13 +11,10 @@
  * \returns true if happy else false
  */
 template <typename T>
-bool is_happy(T n)
-{
-    T s = 0;  // stores sum of digits
-    while (n > 9)
-    {  // while number is > 9, there are more than 1 digit
-        while (n != 0)
-        {  // get digit
+bool is_happy(T n) {
+    T s = 0;              // stores sum of digits
+    while (n > 9) {       // while number is > 9, there are more than 1 digit
+        while (n != 0) {  // get digit
             T d = n % 10;
             s += d;
             n /= 10;
@@ -29,8 +26,7 @@ bool is_happy(T n)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     int n;
     std::cout << "Enter a number:";
     std::cin >> n;
diff --git a/others/matrix_exponentiation.cpp b/others/matrix_exponentiation.cpp
index 78daca8ec..d44d22593 100644
--- a/others/matrix_exponentiation.cpp
+++ b/others/matrix_exponentiation.cpp
@@ -58,15 +58,11 @@ vector<ll> a, b, c;
  * \result matrix of dimension (m\f$\times\f$q)
  */
 vector<vector<ll>> multiply(const vector<vector<ll>> &A,
-                            const vector<vector<ll>> &B)
-{
+                            const vector<vector<ll>> &B) {
     vector<vector<ll>> C(k + 1, vector<ll>(k + 1));
-    for (ll i = 1; i <= k; i++)
-    {
-        for (ll j = 1; j <= k; j++)
-        {
-            for (ll z = 1; z <= k; z++)
-            {
+    for (ll i = 1; i <= k; i++) {
+        for (ll j = 1; j <= k; j++) {
+            for (ll z = 1; z <= k; z++) {
                 C[i][j] = (C[i][j] + (A[i][z] * B[z][j]) % MOD) % MOD;
             }
         }
@@ -80,16 +76,12 @@ vector<vector<ll>> multiply(const vector<vector<ll>> &A,
  * \param [in] p exponent
  * \return matrix of same dimension as A
  */
-vector<vector<ll>> power(const vector<vector<ll>> &A, ll p)
-{
+vector<vector<ll>> power(const vector<vector<ll>> &A, ll p) {
     if (p == 1)
         return A;
-    if (p % 2 == 1)
-    {
+    if (p % 2 == 1) {
         return multiply(A, power(A, p - 1));
-    }
-    else
-    {
+    } else {
         vector<vector<ll>> X = power(A, p / 2);
         return multiply(X, X);
     }
@@ -99,8 +91,7 @@ vector<vector<ll>> power(const vector<vector<ll>> &A, ll p)
  * \param[in] n \f$n^\text{th}\f$ Fibonacci number
  * \return \f$n^\text{th}\f$ Fibonacci number
  */
-ll ans(ll n)
-{
+ll ans(ll n) {
     if (n == 0)
         return 0;
     if (n <= k)
@@ -111,12 +102,9 @@ ll ans(ll n)
 
     // Transpose matrix
     vector<vector<ll>> T(k + 1, vector<ll>(k + 1));
-    for (ll i = 1; i <= k; i++)
-    {
-        for (ll j = 1; j <= k; j++)
-        {
-            if (i < k)
-            {
+    for (ll i = 1; i <= k; i++) {
+        for (ll j = 1; j <= k; j++) {
+            if (i < k) {
                 if (j == i + 1)
                     T[i][j] = 1;
                 else
@@ -131,31 +119,26 @@ ll ans(ll n)
 
     // T*F1
     ll res = 0;
-    for (ll i = 1; i <= k; i++)
-    {
+    for (ll i = 1; i <= k; i++) {
         res = (res + (T[1][i] * F1[i]) % MOD) % MOD;
     }
     return res;
 }
 
 /** Main function */
-int main()
-{
+int main() {
     cin.tie(0);
     cout.tie(0);
     ll t;
     cin >> t;
     ll i, j, x;
-    while (t--)
-    {
+    while (t--) {
         cin >> k;
-        for (i = 0; i < k; i++)
-        {
+        for (i = 0; i < k; i++) {
             cin >> x;
             b.pb(x);
         }
-        for (i = 0; i < k; i++)
-        {
+        for (i = 0; i < k; i++) {
             cin >> x;
             c.pb(x);
         }
diff --git a/others/palindrome_of_number.cpp b/others/palindrome_of_number.cpp
index d6ed3fc70..66401ff96 100644
--- a/others/palindrome_of_number.cpp
+++ b/others/palindrome_of_number.cpp
@@ -16,8 +16,7 @@
 #endif
 
 /** Main function */
-int main()
-{
+int main() {
     int num;
     std::cout << "Enter number = ";
     std::cin >> num;
diff --git a/others/paranthesis_matching.cpp b/others/paranthesis_matching.cpp
index 95a9e1100..2a6358d94 100644
--- a/others/paranthesis_matching.cpp
+++ b/others/paranthesis_matching.cpp
@@ -33,10 +33,8 @@ char pop() { return stack[top--]; }
 /** return opening paranthesis corresponding to the close paranthesis
  * @param[in] ch closed paranthesis character
  */
-char opening(char ch)
-{
-    switch (ch)
-    {
+char opening(char ch) {
+    switch (ch) {
     case '}':
         return '{';
     case ']':
@@ -49,37 +47,27 @@ char opening(char ch)
     return '\0';
 }
 
-int main()
-{
+int main() {
     std::string exp;
     int valid = 1, i = 0;
     std::cout << "Enter The Expression : ";
     std::cin >> exp;
 
-    while (valid == 1 && i < exp.length())
-    {
-        if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<')
-        {
+    while (valid == 1 && i < exp.length()) {
+        if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[' || exp[i] == '<') {
             push(exp[i]);
-        }
-        else if (top >= 0 && stack[top] == opening(exp[i]))
-        {
+        } else if (top >= 0 && stack[top] == opening(exp[i])) {
             pop();
-        }
-        else
-        {
+        } else {
             valid = 0;
         }
         i++;
     }
 
     // makes sure the stack is empty after processsing (above)
-    if (valid == 1 && top == -1)
-    {
+    if (valid == 1 && top == -1) {
         std::cout << "\nCorrect Expression";
-    }
-    else
-    {
+    } else {
         std::cout << "\nWrong Expression";
     }
 
diff --git a/others/pascal_triangle.cpp b/others/pascal_triangle.cpp
index 814b9a142..4ea58f3f1 100644
--- a/others/pascal_triangle.cpp
+++ b/others/pascal_triangle.cpp
@@ -15,12 +15,9 @@
  * \param [in] arr  2D-array containing Pascal numbers
  * \param [in] n    depth of Pascal triangle to print
  */
-void show_pascal(int **arr, int n)
-{
-    for (int i = 0; i < n; ++i)
-    {
-        for (int j = 0; j < n + i; ++j)
-        {
+void show_pascal(int **arr, int n) {
+    for (int i = 0; i < n; ++i) {
+        for (int j = 0; j < n + i; ++j) {
             if (arr[i][j] == 0)
                 std::cout << std::setw(4) << " ";
             else
@@ -36,12 +33,9 @@ void show_pascal(int **arr, int n)
  * \param [in] n    depth of Pascal triangle to print
  * \result arr pointer returned
  */
-int **pascal_triangle(int **arr, int n)
-{
-    for (int i = 0; i < n; ++i)
-    {
-        for (int j = n - i - 1; j < n + i; ++j)
-        {
+int **pascal_triangle(int **arr, int n) {
+    for (int i = 0; i < n; ++i) {
+        for (int j = n - i - 1; j < n + i; ++j) {
             if (j == n - i - 1 || j == n + i - 1)
                 arr[i][j] = 1;  // The edge of the Pascal triangle goes in 1
             else
@@ -55,8 +49,7 @@ int **pascal_triangle(int **arr, int n)
 /**
  * main function
  */
-int main()
-{
+int main() {
     int n = 0;
 
     std::cout << "Set Pascal's Triangle Height" << std::endl;
@@ -64,8 +57,7 @@ int main()
 
     // memory allocation (Assign two-dimensional array to store Pascal triangle)
     int **arr = new int *[n];
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         arr[i] = new int[2 * n - 1];
         memset(arr[i], 0, sizeof(int) * (2 * n - 1));
     }
@@ -74,8 +66,7 @@ int main()
     show_pascal(arr, n);
 
     // deallocation
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         delete[] arr[i];
     }
     delete[] arr;
diff --git a/others/primality_test.cpp b/others/primality_test.cpp
index 16700ec4a..faec6589c 100644
--- a/others/primality_test.cpp
+++ b/others/primality_test.cpp
@@ -15,14 +15,12 @@
  * \param[in] number number to check
  * \returns true if prime else false
  */
-bool IsPrime(int number)
-{
+bool IsPrime(int number) {
     if (((!(number & 1)) && number != 2) || (number < 2) ||
         (number % 3 == 0 && number != 3))
         return false;
 
-    for (int k = 1; 36 * k * k - 12 * k < number; ++k)
-    {
+    for (int k = 1; 36 * k * k - 12 * k < number; ++k) {
         if ((number % (6 * k + 1) == 0) || (number % (6 * k - 1) == 0))
             return false;
     }
@@ -30,8 +28,7 @@ bool IsPrime(int number)
 }
 
 /** main function */
-int main()
-{
+int main() {
     // Main Function
     std::cout << "Enter the value of n to check if Prime\n";
     int n;
diff --git a/others/smallest_circle.cpp b/others/smallest_circle.cpp
index 5842a33c8..9ee4353eb 100644
--- a/others/smallest_circle.cpp
+++ b/others/smallest_circle.cpp
@@ -12,8 +12,7 @@
 #include <vector>
 
 /** Define a point */
-struct Point
-{
+struct Point {
     double x, /**< abscissa */
         y;    /**< ordinate */
 
@@ -21,8 +20,7 @@ struct Point
      * \param [in] a absicca (default = 0.0)
      * \param [in] b ordinate (default = 0.0)
      */
-    explicit Point(double a = 0.f, double b = 0.f)
-    {
+    explicit Point(double a = 0.f, double b = 0.f) {
         x = a;
         y = b;
     }
@@ -36,8 +34,7 @@ struct Point
  * \param [in] B point B
  * \return ditance
  */
-double LenghtLine(const Point &A, const Point &B)
-{
+double LenghtLine(const Point &A, const Point &B) {
     double dx = B.x - A.x;
     double dy = B.y - A.y;
     return std::sqrt((dx * dx) + (dy * dy));
@@ -54,8 +51,7 @@ double LenghtLine(const Point &A, const Point &B)
  * \param [in] C vertex C
  * \returns area of triangle
  */
-double TriangleArea(const Point &A, const Point &B, const Point &C)
-{
+double TriangleArea(const Point &A, const Point &B, const Point &C) {
     double a = LenghtLine(A, B);
     double b = LenghtLine(B, C);
     double c = LenghtLine(C, A);
@@ -73,10 +69,8 @@ double TriangleArea(const Point &A, const Point &B, const Point &C)
  * \returns True if P lies on or within the circle
  * \returns False if P lies outside the circle
  */
-bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R)
-{
-    for (size_t i = 0; i < P.size(); i++)
-    {
+bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R) {
+    for (size_t i = 0; i < P.size(); i++) {
         if (LenghtLine(P[i], Center) > R)
             return false;
     }
@@ -90,8 +84,7 @@ bool PointInCircle(const std::vector<Point> &P, const Point &Center, double R)
  * \param [in] P vector of points
  * \returns radius of the circle
  */
-double circle(const std::vector<Point> &P)
-{
+double circle(const std::vector<Point> &P) {
     double minR = INFINITY;
     double R;
     Point C;
@@ -103,8 +96,7 @@ double circle(const std::vector<Point> &P)
         // for every subsequent point in the list
         for (size_t j = i + 1; j < P.size(); j++)
             // for every subsequent point in the list
-            for (size_t k = j + 1; k < P.size(); k++)
-            {
+            for (size_t k = j + 1; k < P.size(); k++) {
                 // here, we now have picked three points from the given set of
                 // points that we can use
                 // viz., P[i], P[j] and P[k]
@@ -129,12 +121,10 @@ double circle(const std::vector<Point> &P)
                 R = (LenghtLine(P[i], P[j]) * LenghtLine(P[j], P[k]) *
                      LenghtLine(P[k], P[i])) /
                     (4 * TriangleArea(P[i], P[j], P[k]));
-                if (!PointInCircle(P, C, R))
-                {
+                if (!PointInCircle(P, C, R)) {
                     continue;
                 }
-                if (R <= minR)
-                {
+                if (R <= minR) {
                     minR = R;
                     minC = C;
                 }
@@ -143,18 +133,15 @@ double circle(const std::vector<Point> &P)
     // for each point in the list
     for (size_t i = 0; i < P.size() - 1; i++)
         // for every subsequent point in the list
-        for (size_t j = i + 1; j < P.size(); j++)
-        {
+        for (size_t j = i + 1; j < P.size(); j++) {
             // check for diameterically opposite points
             C.x = (P[i].x + P[j].x) / 2;
             C.y = (P[i].y + P[j].y) / 2;
             R = LenghtLine(C, P[i]);
-            if (!PointInCircle(P, C, R))
-            {
+            if (!PointInCircle(P, C, R)) {
                 continue;
             }
-            if (R <= minR)
-            {
+            if (R <= minR) {
                 minR = R;
                 minC = C;
             }
@@ -168,8 +155,7 @@ double circle(const std::vector<Point> &P)
  * \n radius 3.318493136080724
  * \n centre at (3.0454545454545454, 1.3181818181818181)
  */
-void test()
-{
+void test() {
     std::vector<Point> Pv;
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(5, 4));
@@ -184,8 +170,7 @@ void test()
  * \n radius 1.4142135623730951
  * \n centre at (1.0, 1.0)
  */
-void test2()
-{
+void test2() {
     std::vector<Point> Pv;
     Pv.push_back(Point(0, 0));
     Pv.push_back(Point(0, 2));
@@ -200,8 +185,7 @@ void test2()
  * \n centre at (2.142857142857143, 1.7857142857142856)
  * @todo This test fails
  */
-void test3()
-{
+void test3() {
     std::vector<Point> Pv;
     Pv.push_back(Point(0.5, 1));
     Pv.push_back(Point(3.5, 3));
@@ -211,8 +195,7 @@ void test3()
 }
 
 /** Main program */
-int main()
-{
+int main() {
     test();
     std::cout << std::endl;
     test2();
diff --git a/others/sparse_matrix.cpp b/others/sparse_matrix.cpp
index 5662e065d..a358f0da4 100644
--- a/others/sparse_matrix.cpp
+++ b/others/sparse_matrix.cpp
@@ -6,8 +6,7 @@
 #include <iostream>
 
 /** main function */
-int main()
-{
+int main() {
     int m, n;
     int counterZeros = 0;
 
@@ -22,20 +21,16 @@ int main()
     std::cout << "\n";
 
     // reads the matrix from stdin
-    for (int i = 0; i < m; i++)
-    {
-        for (int j = 0; j < n; j++)
-        {
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
             std::cout << "element? ";
             std::cin >> a[i][j];
         }
     }
 
     // counts the zero's
-    for (int i = 0; i < m; i++)
-    {
-        for (int j = 0; j < n; j++)
-        {
+    for (int i = 0; i < m; i++) {
+        for (int j = 0; j < n; j++) {
             if (a[i][j] == 0)
                 counterZeros++;  // Counting number of zeroes
         }
diff --git a/others/spiral_print.cpp b/others/spiral_print.cpp
index da92e6937..02dc3183a 100644
--- a/others/spiral_print.cpp
+++ b/others/spiral_print.cpp
@@ -9,13 +9,10 @@
  * \param [in] r number of rows
  * \param [in] c number of columns
  */
-void genArray(int **a, int r, int c)
-{
+void genArray(int **a, int r, int c) {
     int value = 1;
-    for (int i = 0; i < r; i++)
-    {
-        for (int j = 0; j < c; j++)
-        {
+    for (int i = 0; i < r; i++) {
+        for (int j = 0; j < c; j++) {
             a[i][j] = value;
             std::cout << a[i][j] << " ";
             value++;
@@ -29,47 +26,39 @@ void genArray(int **a, int r, int c)
  * \param [in] r number of rows
  * \param [in] c number of columns
  */
-void spiralPrint(int **a, int r, int c)
-{
+void spiralPrint(int **a, int r, int c) {
     int startRow = 0, endRow = r - 1;
     int startCol = 0, endCol = c - 1;
     int cnt = 0;
 
-    while (startRow <= endRow && startCol <= endCol)
-    {
+    while (startRow <= endRow && startCol <= endCol) {
         /// Print start row
-        for (int i = startCol; i <= endCol; i++, cnt++)
-        {
+        for (int i = startCol; i <= endCol; i++, cnt++) {
             std::cout << a[startRow][i] << " ";
         }
         startRow++;
 
         /// Print the end col
-        for (int i = startRow; i <= endRow; i++, cnt++)
-        {
+        for (int i = startRow; i <= endRow; i++, cnt++) {
             std::cout << a[i][endCol] << " ";
         }
         endCol--;
 
         /// Print the end row
-        if (cnt == r * c)
-        {
+        if (cnt == r * c) {
             break;
         }
 
-        for (int i = endCol; i >= startCol; i--, cnt++)
-        {
+        for (int i = endCol; i >= startCol; i--, cnt++) {
             std::cout << a[endRow][i] << " ";
         }
         endRow--;
 
         /// Print the start Col
-        if (cnt == r * c)
-        {
+        if (cnt == r * c) {
             break;
         }
-        for (int i = endRow; i >= startRow; i--, cnt++)
-        {
+        for (int i = endRow; i >= startRow; i--, cnt++) {
             std::cout << a[i][startCol] << " ";
         }
         startCol++;
@@ -77,8 +66,7 @@ void spiralPrint(int **a, int r, int c)
 }
 
 /** main function */
-int main()
-{
+int main() {
     int r, c;
     std::cin >> r >> c;
     int **a = new int *[r];
diff --git a/others/stairs_pattern.cpp b/others/stairs_pattern.cpp
index bfd90dd10..a3b8b0a44 100644
--- a/others/stairs_pattern.cpp
+++ b/others/stairs_pattern.cpp
@@ -14,23 +14,18 @@ where number of pairs line is given by user
 #include <iostream>
 
 /** main function */
-int main()
-{
+int main() {
     int l, st = 2, x, r, z, n, sp;
     std::cout << "enter Index ";
     std::cin >> x;
     z = x;
-    for (r = 1; r <= x; r++)
-    {
+    for (r = 1; r <= x; r++) {
         z = z - 1;
-        for (n = 1; n <= 2; n++)
-        {
-            for (sp = 1; sp <= z; sp++)
-            {
+        for (n = 1; n <= 2; n++) {
+            for (sp = 1; sp <= z; sp++) {
                 std::cout << " ";
             }
-            for (l = 1; l <= st; l++)
-            {
+            for (l = 1; l <= st; l++) {
                 std::cout << "*";
             }
             std::cout << std::endl;
diff --git a/others/tower_of_hanoi.cpp b/others/tower_of_hanoi.cpp
index 3a832248f..323b2e424 100644
--- a/others/tower_of_hanoi.cpp
+++ b/others/tower_of_hanoi.cpp
@@ -8,8 +8,7 @@
 /**
  * Define the state of tower
  */
-struct tower
-{
+struct tower {
     //! Values in the tower
     int values[10];
     //! top tower ID
@@ -18,21 +17,17 @@ struct tower
 
 /** Display the towers */
 void show(const struct tower *const F, const struct tower *const T,
-          const struct tower *const U)
-{
+          const struct tower *const U) {
     std::cout << "\n\n\tF : ";
-    for (int i = 0; i < F->top; i++)
-    {
+    for (int i = 0; i < F->top; i++) {
         std::cout << F->values[i] << "\t";
     }
     std::cout << "\n\tU : ";
-    for (int i = 0; i < U->top; i++)
-    {
+    for (int i = 0; i < U->top; i++) {
         std::cout << U->values[i] << "\t";
     }
     std::cout << "\n\tT : ";
-    for (int i = 0; i < T->top; i++)
-    {
+    for (int i = 0; i < T->top; i++) {
         std::cout << T->values[i] << "\t";
     }
 }
@@ -41,8 +36,7 @@ void show(const struct tower *const F, const struct tower *const T,
  * \param [in,out] From tower to move disk *from*
  * \param [in,out] To  tower to move disk *to*
  */
-void mov(tower *From, tower *To)
-{
+void mov(tower *From, tower *To) {
     --From->top;
     To->values[To->top] = From->values[From->top];
     ++To->top;
@@ -55,15 +49,11 @@ void mov(tower *From, tower *To)
  * \param [in,out] Using temporary tower for the puzzle
  * \param [in,out] To  tower to move disk to
  */
-void TH(int n, tower *From, tower *Using, tower *To)
-{
-    if (n == 1)
-    {
+void TH(int n, tower *From, tower *Using, tower *To) {
+    if (n == 1) {
         mov(From, To);
         show(From, To, Using);
-    }
-    else
-    {
+    } else {
         TH(n - 1, From, To, Using);
         mov(From, To);
         show(From, To, Using);
@@ -72,8 +62,7 @@ void TH(int n, tower *From, tower *Using, tower *To)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     struct tower F, U, T;
 
     F.top = 0;
@@ -85,8 +74,7 @@ int main()
     std::cout << "\nEnter number of discs : ";
     std::cin >> no;
 
-    for (int i = no; i > 0; i--)
-    {
+    for (int i = no; i > 0; i--) {
         F.values[F.top++] = i;
     }
 
diff --git a/others/vector_important_functions.cpp b/others/vector_important_functions.cpp
index 765f6a8e5..d23ff9c97 100644
--- a/others/vector_important_functions.cpp
+++ b/others/vector_important_functions.cpp
@@ -8,8 +8,7 @@
 #include <vector>
 
 /** Main function */
-int main()
-{
+int main() {
     // Initializing vector with array values
     int arr[] = {10, 20, 5, 23, 42, 15};
     int n = sizeof(arr) / sizeof(arr[0]);
diff --git a/probability/addition_rule.cpp b/probability/addition_rule.cpp
index 0666b29e6..780951489 100644
--- a/probability/addition_rule.cpp
+++ b/probability/addition_rule.cpp
@@ -11,8 +11,7 @@
  * \parama [in] B probability of event B
  * \returns probability of A and B
  */
-double addition_rule_independent(double A, double B)
-{
+double addition_rule_independent(double A, double B) {
     return (A + B) - (A * B);
 }
 
@@ -23,14 +22,12 @@ double addition_rule_independent(double A, double B)
  * \parama [in] B_given_A probability of event B condition A
  * \returns probability of A and B
  */
-double addition_rule_dependent(double A, double B, double B_given_A)
-{
+double addition_rule_dependent(double A, double B, double B_given_A) {
     return (A + B) - (A * B_given_A);
 }
 
 /** Main function */
-int main()
-{
+int main() {
     double A = 0.5;
     double B = 0.25;
     double B_given_A = 0.05;
diff --git a/probability/bayes_theorem.cpp b/probability/bayes_theorem.cpp
index 632611fe5..aaa557a94 100644
--- a/probability/bayes_theorem.cpp
+++ b/probability/bayes_theorem.cpp
@@ -11,22 +11,19 @@
 
 /** returns P(A|B)
  */
-double bayes_AgivenB(double BgivenA, double A, double B)
-{
+double bayes_AgivenB(double BgivenA, double A, double B) {
     return (BgivenA * A) / B;
 }
 
 /** returns P(B|A)
  */
-double bayes_BgivenA(double AgivenB, double A, double B)
-{
+double bayes_BgivenA(double AgivenB, double A, double B) {
     return (AgivenB * B) / A;
 }
 
 /** Main function
  */
-int main()
-{
+int main() {
     double A = 0.01;
     double B = 0.1;
     double BgivenA = 0.9;
diff --git a/probability/binomial_dist.cpp b/probability/binomial_dist.cpp
index 4d2e90842..1f30c5048 100644
--- a/probability/binomial_dist.cpp
+++ b/probability/binomial_dist.cpp
@@ -33,8 +33,7 @@ double binomial_variance(double n, double p) { return n * p * (1 - p); }
  * \param [in] p
  * \returns \f$\sigma = \sqrt{\sigma^2} = \sqrt{n\cdot p\cdot (1-p)}\f$
  */
-double binomial_standard_deviation(double n, double p)
-{
+double binomial_standard_deviation(double n, double p) {
     return std::sqrt(binomial_variance(n, p));
 }
 
@@ -45,18 +44,15 @@ double binomial_standard_deviation(double n, double p)
  * \frac{n!}{r!(n-r)!} = \frac{n\times(n-1)\times(n-2)\times\cdots(n-r)}{r!}
  * \f$
  */
-double nCr(double n, double r)
-{
+double nCr(double n, double r) {
     double numerator = n;
     double denominator = r;
 
-    for (int i = n - 1; i >= ((n - r) + 1); i--)
-    {
+    for (int i = n - 1; i >= ((n - r) + 1); i--) {
         numerator *= i;
     }
 
-    for (int i = 1; i < r; i++)
-    {
+    for (int i = 1; i < r; i++) {
         denominator *= i;
     }
 
@@ -66,8 +62,7 @@ double nCr(double n, double r)
 /** calculates the probability of exactly x successes
  * \returns \f$\displaystyle P(n,p,x) = {n\choose x} p^x (1-p)^{n-x}\f$
  */
-double binomial_x_successes(double n, double p, double x)
-{
+double binomial_x_successes(double n, double p, double x) {
     return nCr(n, x) * std::pow(p, x) * std::pow(1 - p, n - x);
 }
 
@@ -77,19 +72,16 @@ double binomial_x_successes(double n, double p, double x)
  * =\sum_{i=x_0}^{x_1} {n\choose i} p^i (1-p)^{n-i}\f$
  */
 double binomial_range_successes(double n, double p, double lower_bound,
-                                double upper_bound)
-{
+                                double upper_bound) {
     double probability = 0;
-    for (int i = lower_bound; i <= upper_bound; i++)
-    {
+    for (int i = lower_bound; i <= upper_bound; i++) {
         probability += nCr(n, i) * std::pow(p, i) * std::pow(1 - p, n - i);
     }
     return probability;
 }
 
 /** main function */
-int main()
-{
+int main() {
     std::cout << "expected value : " << binomial_expected(100, 0.5)
               << std::endl;
 
diff --git a/probability/poisson_dist.cpp b/probability/poisson_dist.cpp
index 428ee903f..6a2a377c3 100644
--- a/probability/poisson_dist.cpp
+++ b/probability/poisson_dist.cpp
@@ -14,8 +14,7 @@
  * calculate the events per unit time\n
  * e.g 5 dollars every 2 mins = 5 / 2 = 2.5
  */
-double poisson_rate(double events, double timeframe)
-{
+double poisson_rate(double events, double timeframe) {
     return events / timeframe;
 }
 
@@ -28,16 +27,13 @@ double poisson_expected(double rate, double time) { return rate * time; }
 /**
  * Compute factorial of a given number
  */
-double fact(double x)
-{
+double fact(double x) {
     double x_fact = x;
-    for (int i = x - 1; i > 0; i--)
-    {
+    for (int i = x - 1; i > 0; i--) {
         x_fact *= i;
     }
 
-    if (x_fact <= 0)
-    {
+    if (x_fact <= 0) {
         x_fact = 1;
     }
     return x_fact;
@@ -47,8 +43,7 @@ double fact(double x)
  * Find the probability of x successes in a Poisson dist.
  * \f[p(\mu,x) = \frac{\mu^x e^{-\mu}}{x!}\f]
  */
-double poisson_x_successes(double expected, double x)
-{
+double poisson_x_successes(double expected, double x) {
     return (std::pow(expected, x) * std::exp(-expected)) / fact(x);
 }
 
@@ -56,11 +51,9 @@ double poisson_x_successes(double expected, double x)
  * probability of a success in range for Poisson dist (inclusive, inclusive)
  * \f[P = \sum_i p(\mu,i)\f]
  */
-double poisson_range_successes(double expected, double lower, double upper)
-{
+double poisson_range_successes(double expected, double lower, double upper) {
     double probability = 0;
-    for (int i = lower; i <= upper; i++)
-    {
+    for (int i = lower; i <= upper; i++) {
         probability += poisson_x_successes(expected, i);
     }
     return probability;
@@ -69,8 +62,7 @@ double poisson_range_successes(double expected, double lower, double upper)
 /**
  * main function
  */
-int main()
-{
+int main() {
     double rate, expected;
     rate = poisson_rate(3, 1);
     std::cout << "Poisson rate : " << rate << std::endl;
diff --git a/range_queries/bit.cpp b/range_queries/bit.cpp
index 19141b7f5..a1878705b 100644
--- a/range_queries/bit.cpp
+++ b/range_queries/bit.cpp
@@ -3,46 +3,38 @@
 
 using namespace std;
 
-class Bit
-{
+class Bit {
     int n;
     vector<int> bit;
     inline int offset(int x) { return (x & (-x)); }
 
  public:
-    Bit(vector<int>& arr)
-    {
+    Bit(vector<int>& arr) {
         n = arr.size();
         bit.assign(n + 1, 0);
-        for (int i = 0; i < n; ++i)
-        {
+        for (int i = 0; i < n; ++i) {
             update(i, arr[i]);
         }
     }
-    Bit(int x)
-    {
+    Bit(int x) {
         n = x;
         bit.assign(n + 1, 0);
     }
 
-    void update(int id, int val)
-    {
+    void update(int id, int val) {
         // Add val at id
         id++;
-        while (id <= n)
-        {
+        while (id <= n) {
             bit[id] += val;
             id += offset(id);
         }
     }
 
-    int sum(int id)
-    {
+    int sum(int id) {
         // Get prefix sum upto id.
         id++;
         int res = 0;
-        while (id > 0)
-        {
+        while (id > 0) {
             res += bit[id];
             id -= offset(id);
         }
@@ -52,8 +44,7 @@ class Bit
     int sum_range(int l, int r) { return sum(r) - sum(l - 1); }
 };
 
-int main()
-{
+int main() {
     int n = 5;
     vector<int> arr = {1, 2, 3, 4, 5};
     Bit x(arr);
diff --git a/range_queries/fenwicktree.cpp b/range_queries/fenwicktree.cpp
index d78cb0d48..fb7cbaac4 100644
--- a/range_queries/fenwicktree.cpp
+++ b/range_queries/fenwicktree.cpp
@@ -12,19 +12,15 @@ const int maxn = 1e5 + 7;
 int tree[maxn] = {0},
     range;  // segement of [1...range], notice it must be less than `maxn`
 
-void update(int x, int c)
-{
-    while (x <= range)
-    {
+void update(int x, int c) {
+    while (x <= range) {
         tree[x] += c;
         x += lowbit(x);
     }
 }
-int query(int x)
-{
+int query(int x) {
     int ans = 0;
-    while (x)
-    {
+    while (x) {
         ans += tree[x];
         x -= lowbit(x);
     }
@@ -32,29 +28,23 @@ int query(int x)
 }
 int query_segement(int l, int r) { return query(r) - query(l - 1); }
 
-int main()
-{
+int main() {
     cin >> range;
-    for (int i = 1; i <= range; i++)
-    {
+    for (int i = 1; i <= range; i++) {
         int num;
         cin >> num;
         update(i, num);
     }
     int q;
     cin >> q;
-    while (q--)
-    {
+    while (q--) {
         int op;
         cin >> op;
-        if (op == 0)
-        {
+        if (op == 0) {
             int l, r;
             cin >> l >> r;
             cout << query_segement(l, r) << endl;
-        }
-        else
-        {
+        } else {
             int x, c;
             cin >> x >> c;
             update(x, c);
diff --git a/range_queries/mo.cpp b/range_queries/mo.cpp
index 4cdcdf30d..d281ef077 100644
--- a/range_queries/mo.cpp
+++ b/range_queries/mo.cpp
@@ -3,41 +3,35 @@ using namespace std;
 const int N = 1e6 + 5;
 int a[N], bucket[N], cnt[N];
 int bucket_size;
-struct query
-{
+struct query {
     int l, r, i;
 } q[N];
 int ans = 0;
 
-void add(int index)
-{
+void add(int index) {
     cnt[a[index]]++;
     if (cnt[a[index]] == 1)
         ans++;
 }
-void remove(int index)
-{
+void remove(int index) {
     cnt[a[index]]--;
     if (cnt[a[index]] == 0)
         ans--;
 }
 
-bool mycmp(query x, query y)
-{
+bool mycmp(query x, query y) {
     if (x.l / bucket_size != y.l / bucket_size)
         return x.l / bucket_size < y.l / bucket_size;
     return x.r < y.r;
 }
 
-int main()
-{
+int main() {
     int n, t, i, j, k = 0;
     scanf("%d", &n);
     for (i = 0; i < n; i++) scanf("%d", &a[i]);
     bucket_size = ceil(sqrt(n));
     scanf("%d", &t);
-    for (i = 0; i < t; i++)
-    {
+    for (i = 0; i < t; i++) {
         scanf("%d %d", &q[i].l, &q[i].r);
         q[i].l--;
         q[i].r--;
@@ -45,26 +39,21 @@ int main()
     }
     sort(q, q + t, mycmp);
     int left = 0, right = 0;
-    for (i = 0; i < t; i++)
-    {
+    for (i = 0; i < t; i++) {
         int L = q[i].l, R = q[i].r;
-        while (left < L)
-        {
+        while (left < L) {
             remove(left);
             left++;
         }
-        while (left > L)
-        {
+        while (left > L) {
             add(left - 1);
             left--;
         }
-        while (right <= R)
-        {
+        while (right <= R) {
             add(right);
             right++;
         }
-        while (right > R + 1)
-        {
+        while (right > R + 1) {
             remove(right - 1);
             right--;
         }
diff --git a/range_queries/segtree.cpp b/range_queries/segtree.cpp
index fb2bbab13..602b3fd95 100644
--- a/range_queries/segtree.cpp
+++ b/range_queries/segtree.cpp
@@ -3,10 +3,8 @@
 #define MAX 4000000
 using namespace std;
 typedef long long ll;
-void ConsTree(ll arr[], ll segtree[], ll low, ll high, ll pos)
-{
-    if (low == high)
-    {
+void ConsTree(ll arr[], ll segtree[], ll low, ll high, ll pos) {
+    if (low == high) {
         segtree[pos] = arr[low];
         return;
     }
@@ -15,17 +13,14 @@ void ConsTree(ll arr[], ll segtree[], ll low, ll high, ll pos)
     ConsTree(arr, segtree, mid + 1, high, 2 * pos + 2);
     segtree[pos] = segtree[2 * pos + 1] + segtree[2 * pos + 2];
 }
-ll query(ll segtree[], ll lazy[], ll qlow, ll qhigh, ll low, ll high, ll pos)
-{
+ll query(ll segtree[], ll lazy[], ll qlow, ll qhigh, ll low, ll high, ll pos) {
     if (low > high)
         return 0;
     if (qlow > high || qhigh < low)
         return 0;
-    if (lazy[pos] != 0)
-    {
+    if (lazy[pos] != 0) {
         segtree[pos] += lazy[pos] * (high - low + 1);
-        if (low != high)
-        {
+        if (low != high) {
             lazy[2 * pos + 1] += lazy[pos];
             lazy[2 * pos + 2] += lazy[pos];
         }
@@ -38,15 +33,12 @@ ll query(ll segtree[], ll lazy[], ll qlow, ll qhigh, ll low, ll high, ll pos)
            query(segtree, lazy, qlow, qhigh, mid + 1, high, 2 * pos + 2);
 }
 void update(ll segtree[], ll lazy[], ll start, ll end, ll delta, ll low,
-            ll high, ll pos)
-{
+            ll high, ll pos) {
     if (low > high)
         return;
-    if (lazy[pos] != 0)
-    {
+    if (lazy[pos] != 0) {
         segtree[pos] += lazy[pos] * (high - low + 1);
-        if (low != high)
-        {
+        if (low != high) {
             lazy[2 * pos + 1] += lazy[pos];
             lazy[2 * pos + 2] += lazy[pos];
         }
@@ -54,11 +46,9 @@ void update(ll segtree[], ll lazy[], ll start, ll end, ll delta, ll low,
     }
     if (start > high || end < low)
         return;
-    if (start <= low && end >= high)
-    {
+    if (start <= low && end >= high) {
         segtree[pos] += delta * (high - low + 1);
-        if (low != high)
-        {
+        if (low != high) {
             lazy[2 * pos + 1] += delta;
             lazy[2 * pos + 2] += delta;
         }
@@ -69,23 +59,18 @@ void update(ll segtree[], ll lazy[], ll start, ll end, ll delta, ll low,
     update(segtree, lazy, start, end, delta, mid + 1, high, 2 * pos + 2);
     segtree[pos] = segtree[2 * pos + 1] + segtree[2 * pos + 2];
 }
-int main()
-{
+int main() {
     ll n, c;
     scanf("%lld %lld", &n, &c);
     ll arr[n] = {0}, p, q, v, choice;
     ll segtree[MAX], lazy[MAX] = {0};
     ConsTree(arr, segtree, 0, n - 1, 0);
-    while (c--)
-    {
+    while (c--) {
         scanf("%lld", &choice);
-        if (choice == 0)
-        {
+        if (choice == 0) {
             scanf("%lld %lld %lld", &p, &q, &v);
             update(segtree, lazy, p - 1, q - 1, v, 0, n - 1, 0);
-        }
-        else
-        {
+        } else {
             scanf("%lld %lld", &p, &q);
             printf("%lld\n", query(segtree, lazy, p - 1, q - 1, 0, n - 1, 0));
         }
diff --git a/search/binary_search.cpp b/search/binary_search.cpp
index ba0ce7644..66da31d7f 100644
--- a/search/binary_search.cpp
+++ b/search/binary_search.cpp
@@ -12,12 +12,10 @@
  * \returns index if T is found
  * \return -1 if T is not found
  */
-int binary_search(int a[], int r, int key)
-{
+int binary_search(int a[], int r, int key) {
     int l = 0;
 
-    while (l <= r)
-    {
+    while (l <= r) {
         int m = l + (r - l) / 2;
         if (key == a[m])
             return m;
@@ -30,8 +28,7 @@ int binary_search(int a[], int r, int key)
 }
 
 /** main function */
-int main(int argc, char const* argv[])
-{
+int main(int argc, char const* argv[]) {
     int n, key;
     std::cout << "Enter size of array: ";
     std::cin >> n;
@@ -40,8 +37,7 @@ int main(int argc, char const* argv[])
     int* a = new int[n];
 
     // this loop use for store value in Array
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         std::cin >> a[i];
     }
 
diff --git a/search/exponential_search.cpp b/search/exponential_search.cpp
index 276d03246..f57cbf96b 100644
--- a/search/exponential_search.cpp
+++ b/search/exponential_search.cpp
@@ -31,12 +31,10 @@
  * \returns `nullptr` if value not found
  */
 template <class Type>
-inline Type* binary_s(Type* array, size_t size, Type key)
-{
+inline Type* binary_s(Type* array, size_t size, Type key) {
     int32_t lower_index(0), upper_index(size - 1), middle_index;
 
-    while (lower_index <= upper_index)
-    {
+    while (lower_index <= upper_index) {
         middle_index = std::floor((lower_index + upper_index) / 2);
 
         if (*(array + middle_index) < key)
@@ -58,13 +56,10 @@ inline Type* binary_s(Type* array, size_t size, Type key)
  * * Auxiliary Space Complexity O(1)
  */
 template <class Type>
-Type* struzik_search(Type* array, size_t size, Type key)
-{
+Type* struzik_search(Type* array, size_t size, Type key) {
     uint32_t block_front(0), block_size = size == 0 ? 0 : 1;
-    while (block_front != block_size)
-    {
-        if (*(array + block_size - 1) < key)
-        {
+    while (block_front != block_size) {
+        if (*(array + block_size - 1) < key) {
             block_front = block_size;
             (block_size * 2 - 1 < size) ? (block_size *= 2) : block_size = size;
             continue;
@@ -76,8 +71,7 @@ Type* struzik_search(Type* array, size_t size, Type key)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     // TEST CASES
     int* sorted_array = new int[7]{7, 10, 15, 23, 70, 105, 203};
     assert(struzik_search<int>(sorted_array, 7, 0) == nullptr);
diff --git a/search/hash_search.cpp b/search/hash_search.cpp
index c417c114b..6e4caffc3 100644
--- a/search/hash_search.cpp
+++ b/search/hash_search.cpp
@@ -26,8 +26,7 @@ int data[MAX] = {1, 10, 15, 5, 8, 7};  //!< test data
 /**
  * a one-way linked list
  */
-typedef struct list
-{
+typedef struct list {
     int key;            //!< key value for node
     struct list* next;  //!< pointer to next link in the chain
 } node,                 /**< define node as one item list */
@@ -53,8 +52,7 @@ int h(int key) { return key % HASHMAX; }
  * \warning dynamic memory allocated to `n` never gets freed.
  * \todo fix memory leak
  */
-void create_list(int key)
-{  // Construct hash table
+void create_list(int key) {  // Construct hash table
     link p, n;
     int index;
     n = (link)malloc(sizeof(node));
@@ -62,13 +60,10 @@ void create_list(int key)
     n->next = NULL;
     index = h(key);
     p = hashtab[index].next;
-    if (p != NULL)
-    {
+    if (p != NULL) {
         n->next = p;
         hashtab[index].next = n;
-    }
-    else
-    {
+    } else {
         hashtab[index].next = n;
     }
 }
@@ -78,8 +73,7 @@ void create_list(int key)
  * (int key) function, then one-dimensional linear search. If found @return
  * element depth and number of searches If not found @return -1
  */
-int hash_search(int key, int* counter)
-{  // Hash lookup function
+int hash_search(int key, int* counter) {  // Hash lookup function
     link pointer;
     int index;
 
@@ -89,8 +83,7 @@ int hash_search(int key, int* counter)
 
     std::cout << "data[" << index << "]:";
 
-    while (pointer != NULL)
-    {
+    while (pointer != NULL) {
         counter[0]++;
         std::cout << "data[" << pointer->key << "]:";
         if (pointer->key == key)
@@ -103,27 +96,23 @@ int hash_search(int key, int* counter)
 }
 
 /** main function */
-int main()
-{
+int main() {
     link p;
     int key, index, i, counter;  // Key is the value to be found
     index = 0;
 
     // You can write the input mode here
-    while (index < MAX)
-    {  // Construct hash table
+    while (index < MAX) {  // Construct hash table
         create_list(data[index]);
         index++;
     }
 
-    for (i = 0; i < HASHMAX; i++)
-    {  // Output hash table
+    for (i = 0; i < HASHMAX; i++) {  // Output hash table
         std::cout << "hashtab [" << i << "]\n";
 
         p = hashtab[i].next;
 
-        while (p != NULL)
-        {
+        while (p != NULL) {
             std::cout << "please int key:";
             if (p->key > 0)
                 std::cout << "[" << p->key << "]";
@@ -132,8 +121,7 @@ int main()
         std::cout << std::endl;
     }
 
-    while (key != -1)
-    {
+    while (key != -1) {
         // You can write the input mode here
         // test key = 10
         key = 10;
diff --git a/search/interpolation_search.cpp b/search/interpolation_search.cpp
index 0b356b119..4339dc366 100644
--- a/search/interpolation_search.cpp
+++ b/search/interpolation_search.cpp
@@ -12,13 +12,11 @@
  * \returns index where the value is found
  * \returns 0 if not found
  */
-int interpolation_search(int arr[], int value, int len)
-{
+int interpolation_search(int arr[], int value, int len) {
     int low = 0, high, mid;
     high = len - 1;
 
-    while (arr[low] <= value && arr[high] >= value)
-    {
+    while (arr[low] <= value && arr[high] >= value) {
         mid = (low +
                ((value - arr[low]) * (high - low)) / (arr[high] - arr[low]));
         if (arr[mid] > value)
@@ -36,8 +34,7 @@ int interpolation_search(int arr[], int value, int len)
 }
 
 /** main function */
-int main()
-{
+int main() {
     int n, value, re;
 
     std::cout << "Enter the size of array(less than 100) : ";
diff --git a/search/interpolation_search2.cpp b/search/interpolation_search2.cpp
index 9400c5f96..93fa6cd83 100644
--- a/search/interpolation_search2.cpp
+++ b/search/interpolation_search2.cpp
@@ -12,12 +12,10 @@
  * \returns index where the value is found
  * \returns -1 if not found
  */
-int InterpolationSearch(int A[], int n, int x)
-{
+int InterpolationSearch(int A[], int n, int x) {
     int low = 0;
     int high = n - 1;
-    while (low <= high)
-    {
+    while (low <= high) {
         int mid = low + (((high - 1) * (x - A[low])) / (A[high] - A[low]));
         if (x == A[mid])
             return mid;  // Found x, return (exit)
@@ -31,8 +29,7 @@ int InterpolationSearch(int A[], int n, int x)
 }
 
 /** main function */
-int main()
-{
+int main() {
     int A[] = {2, 4, 5, 7, 13, 14, 15, 23};
     int x = 17;
 
diff --git a/search/jump_search.cpp b/search/jump_search.cpp
index b854ac6f9..f7b100a4e 100644
--- a/search/jump_search.cpp
+++ b/search/jump_search.cpp
@@ -9,16 +9,14 @@
 
 /** jump search implementation
  */
-int jumpSearch(int arr[], int x, int n)
-{
+int jumpSearch(int arr[], int x, int n) {
     // Finding block size to be jumped
     int step = std::sqrt(n);
 
     // Finding the block where element is
     // present (if it is present)
     int prev = 0;
-    while (arr[std::min(step, n) - 1] < x)
-    {
+    while (arr[std::min(step, n) - 1] < x) {
         prev = step;
         step += std::sqrt(n);
         if (prev >= n)
@@ -27,8 +25,7 @@ int jumpSearch(int arr[], int x, int n)
 
     // Doing a linear search for x in block
     // beginning with prev.
-    while (arr[prev] < x)
-    {
+    while (arr[prev] < x) {
         prev++;
 
         // If we reached next block or end of
@@ -44,8 +41,7 @@ int jumpSearch(int arr[], int x, int n)
 }
 
 // Driver program to test function
-int main()
-{
+int main() {
     int arr[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610};
     int x = 55;
     int n = sizeof(arr) / sizeof(arr[0]);
diff --git a/search/linear_search.cpp b/search/linear_search.cpp
index b8fd798a7..142506951 100644
--- a/search/linear_search.cpp
+++ b/search/linear_search.cpp
@@ -13,12 +13,9 @@
  * \returns index where the key-value occurs in the array
  * \returns -1 if key-value not found
  */
-int LinearSearch(int *array, int size, int key)
-{
-    for (int i = 0; i < size; ++i)
-    {
-        if (array[i] == key)
-        {
+int LinearSearch(int *array, int size, int key) {
+    for (int i = 0; i < size; ++i) {
+        if (array[i] == key) {
             return i;
         }
     }
@@ -27,8 +24,7 @@ int LinearSearch(int *array, int size, int key)
 }
 
 /** main function */
-int main()
-{
+int main() {
     int size;
     std::cout << "\nEnter the size of the Array : ";
     std::cin >> size;
@@ -38,8 +34,7 @@ int main()
 
     // Input array
     std::cout << "\nEnter the Array of " << size << " numbers : ";
-    for (int i = 0; i < size; i++)
-    {
+    for (int i = 0; i < size; i++) {
         std::cin >> array[i];
     }
 
@@ -47,12 +42,9 @@ int main()
     std::cin >> key;
 
     int index = LinearSearch(array, size, key);
-    if (index != -1)
-    {
+    if (index != -1) {
         std::cout << "\nNumber found at index : " << index;
-    }
-    else
-    {
+    } else {
         std::cout << "\nNot found";
     }
 
diff --git a/search/median_search.cpp b/search/median_search.cpp
index 433ffc1f7..7379cad26 100644
--- a/search/median_search.cpp
+++ b/search/median_search.cpp
@@ -14,25 +14,18 @@
  * @todo add documentation
  */
 template <class X>
-void comp(X x, std::vector<int> *s1, std::vector<int> *s2, std::vector<int> *s3)
-{
-    if (s1->size() >= x && s1->size() + s2->size() < x)
-    {
+void comp(X x, std::vector<int> *s1, std::vector<int> *s2,
+          std::vector<int> *s3) {
+    if (s1->size() >= x && s1->size() + s2->size() < x) {
         std::cout << (*s2)[0] << " is the " << x + 1 << "th element from front";
-    }
-    else if (s1->size() > x)
-    {
+    } else if (s1->size() > x) {
         std::sort(s1->begin(), s1->end());
         std::cout << (*s1)[x] << " is the " << x + 1 << "th element from front";
-    }
-    else if (s1->size() + s2->size() <= x && s3->size() > x)
-    {
+    } else if (s1->size() + s2->size() <= x && s3->size() > x) {
         std::sort(s3->begin(), s3->end());
         std::cout << (*s3)[x - s1->size() - s2->size()] << " is the " << x + 1
                   << "th element from front";
-    }
-    else
-    {
+    } else {
         std::cout << x + 1 << " is invalid location";
     }
 }
@@ -42,8 +35,7 @@ void comp(X x, std::vector<int> *s1, std::vector<int> *s2, std::vector<int> *s3)
 /**
  * Main function
  */
-int main()
-{
+int main() {
     std::vector<int> v{25, 21, 98, 100, 76, 22, 43, 60, 89, 87};
     std::vector<int> s1;
     std::vector<int> s2;
@@ -62,20 +54,14 @@ int main()
     std::cout << "\nmedian=" << median << std::endl;
     int avg1, avg2, avg3, sum1 = 0, sum2 = 0, sum3 = 0;
 
-    for (int i = 0; i < v.size(); i++)
-    {  // iterate through all numbers
-        if (v.back() == v[median])
-        {
+    for (int i = 0; i < v.size(); i++) {  // iterate through all numbers
+        if (v.back() == v[median]) {
             avg1 = sum1 + v.back();
             s2.push_back(v.back());
-        }
-        else if (v.back() < v[median])
-        {
+        } else if (v.back() < v[median]) {
             avg2 = sum2 + v.back();
             s1.push_back(v.back());
-        }
-        else
-        {
+        } else {
             avg3 = sum3 + v.back();
             s3.push_back(v.back());
         }
diff --git a/search/ternary_search.cpp b/search/ternary_search.cpp
index f1e2eccf0..73b89da7a 100644
--- a/search/ternary_search.cpp
+++ b/search/ternary_search.cpp
@@ -45,14 +45,10 @@ void get_input() {}
  * \returns index where the target value was found
  * \returns -1 if target value not found
  */
-int it_ternary_search(int left, int right, int A[], int target)
-{
-    while (1)
-    {
-        if (left < right)
-        {
-            if (right - left < absolutePrecision)
-            {
+int it_ternary_search(int left, int right, int A[], int target) {
+    while (1) {
+        if (left < right) {
+            if (right - left < absolutePrecision) {
                 for (int i = left; i <= right; i++)
                     if (A[i] == target)
                         return i;
@@ -75,9 +71,7 @@ int it_ternary_search(int left, int right, int A[], int target)
 
             else
                 left = oneThird + 1, right = twoThird - 1;
-        }
-        else
-        {
+        } else {
             return -1;
         }
     }
@@ -93,12 +87,9 @@ int it_ternary_search(int left, int right, int A[], int target)
  * \returns index where the target value was found
  * \returns -1 if target value not found
  */
-int rec_ternary_search(int left, int right, int A[], int target)
-{
-    if (left < right)
-    {
-        if (right - left < absolutePrecision)
-        {
+int rec_ternary_search(int left, int right, int A[], int target) {
+    if (left < right) {
+        if (right - left < absolutePrecision) {
             for (int i = left; i <= right; i++)
                 if (A[i] == target)
                     return i;
@@ -120,9 +111,7 @@ int rec_ternary_search(int left, int right, int A[], int target)
             return rec_ternary_search(twoThird + 1, right, A, target);
 
         return rec_ternary_search(oneThird + 1, twoThird - 1, A, target);
-    }
-    else
-    {
+    } else {
         return -1;
     }
 }
@@ -135,16 +124,14 @@ int rec_ternary_search(int left, int right, int A[], int target)
  * \param[in] A array to search in
  * \param[in] target value to search for
  */
-void ternary_search(int N, int A[], int target)
-{
+void ternary_search(int N, int A[], int target) {
     std::cout << it_ternary_search(0, N - 1, A, target) << '\t';
     std::cout << rec_ternary_search(0, N - 1, A, target) << '\t';
     std::cout << std::endl;
 }
 
 /** Main function */
-int main()
-{
+int main() {
     int N = 21;
     int A[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 10};
     get_input();
diff --git a/search/text_search.cpp b/search/text_search.cpp
index a228d23b2..ee66a506a 100644
--- a/search/text_search.cpp
+++ b/search/text_search.cpp
@@ -12,8 +12,7 @@
 
 /** Main function
  */
-int main()
-{
+int main() {
     std::string paragraph;
     std::cout << "Please enter your paragraph: \n";
     std::getline(std::cin, paragraph);
@@ -21,25 +20,18 @@ int main()
     std::cout << "\nThe size of your paragraph = " << paragraph.size()
               << " characters. \n\n";
 
-    if (paragraph.empty())
-    {
+    if (paragraph.empty()) {
         std::cout << "\nThe paragraph is empty" << std::endl;
-    }
-    else
-    {
-        while (true)
-        {
+    } else {
+        while (true) {
             std::string word;
             std::cout << "Please enter the word you are searching for: ";
             std::getline(std::cin, word);
             std::cout << "Hello, your word is " << word << "!\n";
-            if (paragraph.find(word) == std::string::npos)
-            {
+            if (paragraph.find(word) == std::string::npos) {
                 std::cout << word << " does not exist in the sentence"
                           << std::endl;
-            }
-            else
-            {
+            } else {
                 std::cout << "The word " << word << " is now found at location "
                           << paragraph.find(word) << std::endl
                           << std::endl;
diff --git a/sorting/bead_sort.cpp b/sorting/bead_sort.cpp
index 0215fc769..f3276bfcd 100644
--- a/sorting/bead_sort.cpp
+++ b/sorting/bead_sort.cpp
@@ -5,8 +5,7 @@
 #define BEAD(i, j) beads[i * max + j]
 
 // function to perform the above algorithm
-void beadSort(int *a, int len)
-{
+void beadSort(int *a, int len) {
     // Find the maximum element
     int max = a[0];
     for (int i = 1; i < len; i++)
@@ -21,12 +20,10 @@ void beadSort(int *a, int len)
     for (int i = 0; i < len; i++)
         for (int j = 0; j < a[i]; j++) BEAD(i, j) = 1;
 
-    for (int j = 0; j < max; j++)
-    {
+    for (int j = 0; j < max; j++) {
         // count how many beads are on each post
         int sum = 0;
-        for (int i = 0; i < len; i++)
-        {
+        for (int i = 0; i < len; i++) {
             sum += BEAD(i, j);
             BEAD(i, j) = 0;
         }
@@ -36,11 +33,9 @@ void beadSort(int *a, int len)
     }
 
     // Put sorted values in array using beads
-    for (int i = 0; i < len; i++)
-    {
+    for (int i = 0; i < len; i++) {
         int j;
-        for (j = 0; j < max && BEAD(i, j); j++)
-        {
+        for (j = 0; j < max && BEAD(i, j); j++) {
         }
 
         a[i] = j;
@@ -49,8 +44,7 @@ void beadSort(int *a, int len)
 }
 
 // driver function to test the algorithm
-int main()
-{
+int main() {
     int a[] = {5, 3, 1, 7, 4, 1, 1, 20};
     int len = sizeof(a) / sizeof(a[0]);
 
diff --git a/sorting/bitonic_sort.cpp b/sorting/bitonic_sort.cpp
index 7f47cbac6..0fbb995ac 100644
--- a/sorting/bitonic_sort.cpp
+++ b/sorting/bitonic_sort.cpp
@@ -9,8 +9,7 @@
 /*The parameter dir indicates the sorting direction, ASCENDING
    or DESCENDING; if (a[i] > a[j]) agrees with the direction,
    then a[i] and a[j] are interchanged.*/
-void compAndSwap(int a[], int i, int j, int dir)
-{
+void compAndSwap(int a[], int i, int j, int dir) {
     if (dir == (a[i] > a[j]))
         std::swap(a[i], a[j]);
 }
@@ -19,10 +18,8 @@ void compAndSwap(int a[], int i, int j, int dir)
   if dir = 1, and in descending order otherwise (means dir=0).
   The sequence to be sorted starts at index position low,
   the parameter cnt is the number of elements to be sorted.*/
-void bitonicMerge(int a[], int low, int cnt, int dir)
-{
-    if (cnt > 1)
-    {
+void bitonicMerge(int a[], int low, int cnt, int dir) {
+    if (cnt > 1) {
         int k = cnt / 2;
         for (int i = low; i < low + k; i++) compAndSwap(a, i, i + k, dir);
         bitonicMerge(a, low, k, dir);
@@ -33,10 +30,8 @@ void bitonicMerge(int a[], int low, int cnt, int dir)
 /* This function first produces a bitonic sequence by recursively
     sorting its two halves in opposite sorting orders, and then
     calls bitonicMerge to make them in the same order */
-void bitonicSort(int a[], int low, int cnt, int dir)
-{
-    if (cnt > 1)
-    {
+void bitonicSort(int a[], int low, int cnt, int dir) {
+    if (cnt > 1) {
         int k = cnt / 2;
 
         // sort in ascending order since dir here is 1
@@ -56,8 +51,7 @@ void bitonicSort(int a[], int low, int cnt, int dir)
 void sort(int a[], int N, int up) { bitonicSort(a, 0, N, up); }
 
 // Driver code
-int main()
-{
+int main() {
     int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
     int N = sizeof(a) / sizeof(a[0]);
 
diff --git a/sorting/bubble_sort.cpp b/sorting/bubble_sort.cpp
index 8d2a33dcd..c43e425fc 100644
--- a/sorting/bubble_sort.cpp
+++ b/sorting/bubble_sort.cpp
@@ -40,8 +40,7 @@ optimized bubble sort algorithm. It's right down there.
 #include <iostream>
 #include <vector>
 
-int main()
-{
+int main() {
     int n;
     bool swap_check = true;
     std::cout << "Enter the amount of numbers to sort: ";
@@ -51,20 +50,16 @@ int main()
     int num;
 
     // Input
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         std::cin >> num;
         numbers.push_back(num);
     }
 
     // Bubble Sorting
-    for (int i = 0; (i < n) && (swap_check); i++)
-    {
+    for (int i = 0; (i < n) && (swap_check); i++) {
         swap_check = false;
-        for (int j = 0; j < n - 1 - i; j++)
-        {
-            if (numbers[j] > numbers[j + 1])
-            {
+        for (int j = 0; j < n - 1 - i; j++) {
+            if (numbers[j] > numbers[j + 1]) {
                 swap_check = true;
                 std::swap(numbers[j],
                           numbers[j + 1]);  // by changing swap location.
@@ -77,14 +72,10 @@ int main()
 
     // Output
     std::cout << "\nSorted Array : ";
-    for (int i = 0; i < numbers.size(); i++)
-    {
-        if (i != numbers.size() - 1)
-        {
+    for (int i = 0; i < numbers.size(); i++) {
+        if (i != numbers.size() - 1) {
             std::cout << numbers[i] << ", ";
-        }
-        else
-        {
+        } else {
             std::cout << numbers[i] << std::endl;
         }
     }
diff --git a/sorting/bucket_sort.cpp b/sorting/bucket_sort.cpp
index ee945627c..c43865281 100644
--- a/sorting/bucket_sort.cpp
+++ b/sorting/bucket_sort.cpp
@@ -4,14 +4,12 @@
 #include <vector>
 
 // Function to sort arr[] of size n using bucket sort
-void bucketSort(float arr[], int n)
-{
+void bucketSort(float arr[], int n) {
     // 1) Create n empty buckets
     std::vector<float> *b = new std::vector<float>[n];
 
     // 2) Put array elements in different buckets
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         int bi = n * arr[i];  // Index in bucket
         b[bi].push_back(arr[i]);
     }
@@ -27,8 +25,7 @@ void bucketSort(float arr[], int n)
 }
 
 /* Driver program to test above funtion */
-int main()
-{
+int main() {
     float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
     int n = sizeof(arr) / sizeof(arr[0]);
     bucketSort(arr, n);
diff --git a/sorting/cocktail_selection_sort.cpp b/sorting/cocktail_selection_sort.cpp
index ef3d30752..157acafce 100644
--- a/sorting/cocktail_selection_sort.cpp
+++ b/sorting/cocktail_selection_sort.cpp
@@ -9,35 +9,27 @@
 
 // Iterative Version
 
-void CocktailSelectionSort(std::vector<int> *vec, int low, int high)
-{
-    while (low <= high)
-    {
+void CocktailSelectionSort(std::vector<int> *vec, int low, int high) {
+    while (low <= high) {
         int minimum = (*vec)[low];
         int minimumindex = low;
         int maximum = (*vec)[high];
         int maximumindex = high;
 
-        for (int i = low; i <= high; i++)
-        {
-            if ((*vec)[i] >= maximum)
-            {
+        for (int i = low; i <= high; i++) {
+            if ((*vec)[i] >= maximum) {
                 maximum = (*vec)[i];
                 maximumindex = i;
             }
-            if ((*vec)[i] <= minimum)
-            {
+            if ((*vec)[i] <= minimum) {
                 minimum = (*vec)[i];
                 minimumindex = i;
             }
         }
-        if (low != maximumindex || high != minimumindex)
-        {
+        if (low != maximumindex || high != minimumindex) {
             std::swap((*vec)[low], (*vec)[minimumindex]);
             std::swap((*vec)[high], (*vec)[maximumindex]);
-        }
-        else
-        {
+        } else {
             std::swap((*vec)[low], (*vec)[high]);
         }
 
@@ -48,8 +40,7 @@ void CocktailSelectionSort(std::vector<int> *vec, int low, int high)
 
 // Recursive Version
 
-void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high)
-{
+void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high) {
     if (low >= high)
         return;
 
@@ -58,26 +49,20 @@ void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high)
     int maximum = (*vec)[high];
     int maximumindex = high;
 
-    for (int i = low; i <= high; i++)
-    {
-        if ((*vec)[i] >= maximum)
-        {
+    for (int i = low; i <= high; i++) {
+        if ((*vec)[i] >= maximum) {
             maximum = (*vec)[i];
             maximumindex = i;
         }
-        if ((*vec)[i] <= minimum)
-        {
+        if ((*vec)[i] <= minimum) {
             minimum = (*vec)[i];
             minimumindex = i;
         }
     }
-    if (low != maximumindex || high != minimumindex)
-    {
+    if (low != maximumindex || high != minimumindex) {
         std::swap((*vec)[low], (*vec)[minimumindex]);
         std::swap((*vec)[high], (*vec)[maximumindex]);
-    }
-    else
-    {
+    } else {
         std::swap((*vec)[low], (*vec)[high]);
     }
 
@@ -86,15 +71,13 @@ void CocktailSelectionSort_v2(std::vector<int> *vec, int low, int high)
 
 // main function, select any one of iterative or recursive version
 
-int main()
-{
+int main() {
     int n;
     std::cout << "Enter number of elements\n";
     std::cin >> n;
     std::vector<int> v(n);
     std::cout << "Enter all the elements\n";
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         std::cin >> v[i];
     }
 
@@ -102,22 +85,16 @@ int main()
     std::cout << "Enter method: \n\t0: iterative\n\t1: recursive:\t";
     std::cin >> method;
 
-    if (method == 0)
-    {
+    if (method == 0) {
         CocktailSelectionSort(&v, 0, n - 1);
-    }
-    else if (method == 1)
-    {
+    } else if (method == 1) {
         CocktailSelectionSort_v2(&v, 0, n - 1);
-    }
-    else
-    {
+    } else {
         std::cerr << "Unknown method" << std::endl;
         return -1;
     }
     std::cout << "Sorted elements are\n";
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         std::cout << v[i] << " ";
     }
 
diff --git a/sorting/comb_sort.cpp b/sorting/comb_sort.cpp
index d554ac757..1b0a4d706 100644
--- a/sorting/comb_sort.cpp
+++ b/sorting/comb_sort.cpp
@@ -8,15 +8,13 @@
 int a[100005];
 int n;
 
-int FindNextGap(int x)
-{
+int FindNextGap(int x) {
     x = (x * 10) / 13;
 
     return std::max(1, x);
 }
 
-void CombSort(int a[], int l, int r)
-{
+void CombSort(int a[], int l, int r) {
     // Init gap
     int gap = n;
 
@@ -24,18 +22,15 @@ void CombSort(int a[], int l, int r)
     bool swapped = true;
 
     // Keep running until gap = 1 or none elements were swapped
-    while (gap != 1 || swapped)
-    {
+    while (gap != 1 || swapped) {
         // Find next gap
         gap = FindNextGap(gap);
 
         swapped = false;
 
         // Compare all elements with current gap
-        for (int i = l; i <= r - gap; ++i)
-        {
-            if (a[i] > a[i + gap])
-            {
+        for (int i = l; i <= r - gap; ++i) {
+            if (a[i] > a[i + gap]) {
                 std::swap(a[i], a[i + gap]);
                 swapped = true;
             }
@@ -43,8 +38,7 @@ void CombSort(int a[], int l, int r)
     }
 }
 
-int main()
-{
+int main() {
     std::cin >> n;
     for (int i = 1; i <= n; ++i) std::cin >> a[i];
 
diff --git a/sorting/counting_sort.cpp b/sorting/counting_sort.cpp
index 9dadd48cc..1fbfc0fa3 100644
--- a/sorting/counting_sort.cpp
+++ b/sorting/counting_sort.cpp
@@ -1,8 +1,7 @@
 #include <iostream>
 using namespace std;
 
-int Max(int Arr[], int N)
-{
+int Max(int Arr[], int N) {
     int max = Arr[0];
     for (int i = 1; i < N; i++)
         if (Arr[i] > max)
@@ -10,8 +9,7 @@ int Max(int Arr[], int N)
     return max;
 }
 
-int Min(int Arr[], int N)
-{
+int Min(int Arr[], int N) {
     int min = Arr[0];
     for (int i = 1; i < N; i++)
         if (Arr[i] < min)
@@ -19,13 +17,11 @@ int Min(int Arr[], int N)
     return min;
 }
 
-void Print(int Arr[], int N)
-{
+void Print(int Arr[], int N) {
     for (int i = 0; i < N; i++) cout << Arr[i] << ", ";
 }
 
-int *Counting_Sort(int Arr[], int N)
-{
+int *Counting_Sort(int Arr[], int N) {
     int max = Max(Arr, N);
     int min = Min(Arr, N);
     int *Sorted_Arr = new int[N];
@@ -36,8 +32,7 @@ int *Counting_Sort(int Arr[], int N)
 
     for (int i = 1; i < (max - min + 1); i++) Count[i] += Count[i - 1];
 
-    for (int i = N - 1; i >= 0; i--)
-    {
+    for (int i = N - 1; i >= 0; i--) {
         Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
         Count[Arr[i] - min]--;
     }
@@ -45,8 +40,7 @@ int *Counting_Sort(int Arr[], int N)
     return Sorted_Arr;
 }
 
-int main()
-{
+int main() {
     int Arr[] = {47, 65, 20, 66, 25, 53, 64, 69, 72, 22,
                  74, 25, 53, 15, 42, 36, 4,  69, 86, 19},
         N = 20;
diff --git a/sorting/counting_sort_string.cpp b/sorting/counting_sort_string.cpp
index 77e8cdf89..977f3484d 100644
--- a/sorting/counting_sort_string.cpp
+++ b/sorting/counting_sort_string.cpp
@@ -3,8 +3,7 @@
 
 using namespace std;
 
-void countSort(string arr)
-{
+void countSort(string arr) {
     string output;
 
     int count[256], i;
@@ -14,8 +13,7 @@ void countSort(string arr)
 
     for (i = 1; i <= 256; ++i) count[i] += count[i - 1];
 
-    for (i = 0; arr[i]; ++i)
-    {
+    for (i = 0; arr[i]; ++i) {
         output[count[arr[i]] - 1] = arr[i];
         --count[arr[i]];
     }
@@ -25,8 +23,7 @@ void countSort(string arr)
     cout << "Sorted character array is " << arr;
 }
 
-int main()
-{
+int main() {
     string arr;
     cin >> arr;
 
diff --git a/sorting/heap_sort.cpp b/sorting/heap_sort.cpp
index b9b62a5f6..9948bb821 100644
--- a/sorting/heap_sort.cpp
+++ b/sorting/heap_sort.cpp
@@ -1,8 +1,7 @@
 #include <algorithm>
 #include <iostream>
 
-void heapify(int *a, int i, int n)
-{
+void heapify(int *a, int i, int n) {
     int largest = i;
     const int l = 2 * i + 1;
     const int r = 2 * i + 2;
@@ -13,38 +12,31 @@ void heapify(int *a, int i, int n)
     if (r < n && a[r] > a[largest])
         largest = r;
 
-    if (largest != i)
-    {
+    if (largest != i) {
         std::swap(a[i], a[largest]);
         heapify(a, n, largest);
     }
 }
 
-void heapsort(int *a, int n)
-{
-    for (int i = n - 1; i >= 0; --i)
-    {
+void heapsort(int *a, int n) {
+    for (int i = n - 1; i >= 0; --i) {
         std::swap(a[0], a[i]);
         heapify(a, 0, i);
     }
 }
 
-void build_maxheap(int *a, int n)
-{
-    for (int i = n / 2 - 1; i >= 0; --i)
-    {
+void build_maxheap(int *a, int n) {
+    for (int i = n / 2 - 1; i >= 0; --i) {
         heapify(a, i, n);
     }
 }
 
-int main()
-{
+int main() {
     int n;
     std::cout << "Enter number of elements of array\n";
     std::cin >> n;
     int a[20];
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         std::cout << "Enter Element " << i << std::endl;
         std::cin >> a[i];
     }
@@ -52,8 +44,7 @@ int main()
     build_maxheap(a, n);
     heapsort(a, n);
     std::cout << "Sorted Output\n";
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         std::cout << a[i] << std::endl;
     }
 
diff --git a/sorting/insertion_sort.cpp b/sorting/insertion_sort.cpp
index b96a44c47..fe920ca59 100644
--- a/sorting/insertion_sort.cpp
+++ b/sorting/insertion_sort.cpp
@@ -2,8 +2,7 @@
 
 #include <iostream>
 
-int main()
-{
+int main() {
     int n;
     std::cout << "\nEnter the length of your array : ";
     std::cin >> n;
@@ -11,18 +10,15 @@ int main()
     std::cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
 
     // Input
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         std::cin >> Array[i];
     }
 
     // Sorting
-    for (int i = 1; i < n; i++)
-    {
+    for (int i = 1; i < n; i++) {
         int temp = Array[i];
         int j = i - 1;
-        while (j >= 0 && temp < Array[j])
-        {
+        while (j >= 0 && temp < Array[j]) {
             Array[j + 1] = Array[j];
             j--;
         }
@@ -31,8 +27,7 @@ int main()
 
     // Output
     std::cout << "\nSorted Array : ";
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         std::cout << Array[i] << "\t";
     }
 
diff --git a/sorting/library_sort.cpp b/sorting/library_sort.cpp
index c0fa857e7..c9cba88d8 100644
--- a/sorting/library_sort.cpp
+++ b/sorting/library_sort.cpp
@@ -1,8 +1,7 @@
 #include <algorithm>
 #include <iostream>
 
-void librarySort(int *index, int n)
-{
+void librarySort(int *index, int n) {
     int lib_size, index_pos,
         *gaps,        // gaps
         *library[2];  // libraries
@@ -19,8 +18,7 @@ void librarySort(int *index, int n)
     target_lib = 0;
     library[target_lib][0] = index[0];
 
-    while (index_pos < n)
-    {
+    while (index_pos < n) {
         // binary search
         int insert = std::distance(
             library[target_lib],
@@ -29,23 +27,19 @@ void librarySort(int *index, int n)
 
         // if there is no gap to insert a new index ...
 
-        if (numbered[insert] == true)
-        {
+        if (numbered[insert] == true) {
             int prov_size = 0, next_target_lib = !target_lib;
 
             // update library and clear gaps
 
-            for (int i = 0; i <= n; i++)
-            {
-                if (numbered[i] == true)
-                {
+            for (int i = 0; i <= n; i++) {
+                if (numbered[i] == true) {
                     library[next_target_lib][prov_size] = gaps[i];
                     prov_size++;
                     numbered[i] = false;
                 }
 
-                if (i <= lib_size)
-                {
+                if (i <= lib_size) {
                     library[next_target_lib][prov_size] =
                         library[target_lib][i];
                     prov_size++;
@@ -54,9 +48,7 @@ void librarySort(int *index, int n)
 
             target_lib = next_target_lib;
             lib_size = prov_size - 1;
-        }
-        else
-        {
+        } else {
             numbered[insert] = true;
             gaps[insert] = index[index_pos];
             index_pos++;
@@ -64,17 +56,14 @@ void librarySort(int *index, int n)
     }
 
     int index_pos_for_output = 0;
-    for (int i = 0; index_pos_for_output < n; i++)
-    {
-        if (numbered[i] == true)
-        {
+    for (int i = 0; index_pos_for_output < n; i++) {
+        if (numbered[i] == true) {
             // std::cout << gaps[i] << std::endl;
             index[index_pos_for_output] = gaps[i];
             index_pos_for_output++;
         }
 
-        if (i < lib_size)
-        {
+        if (i < lib_size) {
             // std::cout << library[target_lib][i] << std::endl;
             index[index_pos_for_output] = library[target_lib][i];
             index_pos_for_output++;
@@ -82,8 +71,7 @@ void librarySort(int *index, int n)
     }
 }
 
-int main()
-{
+int main() {
     // ---example--
     int index_ex[] = {-6, 5, 9, 1, 9, 1, 0, 1, -8, 4, -12};
     int n_ex = sizeof(index_ex) / sizeof(index_ex[0]);
diff --git a/sorting/merge_sort.cpp b/sorting/merge_sort.cpp
index 1a394ded9..82ab869cd 100644
--- a/sorting/merge_sort.cpp
+++ b/sorting/merge_sort.cpp
@@ -1,7 +1,6 @@
 #include <iostream>
 
-void merge(int arr[], int l, int m, int r)
-{
+void merge(int arr[], int l, int m, int r) {
     int i, j, k;
     int n1 = m - l + 1;
     int n2 = r - m;
@@ -14,30 +13,24 @@ void merge(int arr[], int l, int m, int r)
     i = 0;
     j = 0;
     k = l;
-    while (i < n1 && j < n2)
-    {
-        if (L[i] <= R[j])
-        {
+    while (i < n1 && j < n2) {
+        if (L[i] <= R[j]) {
             arr[k] = L[i];
             i++;
-        }
-        else
-        {
+        } else {
             arr[k] = R[j];
             j++;
         }
         k++;
     }
 
-    while (i < n1)
-    {
+    while (i < n1) {
         arr[k] = L[i];
         i++;
         k++;
     }
 
-    while (j < n2)
-    {
+    while (j < n2) {
         arr[k] = R[j];
         j++;
         k++;
@@ -47,10 +40,8 @@ void merge(int arr[], int l, int m, int r)
     delete[] R;
 }
 
-void mergeSort(int arr[], int l, int r)
-{
-    if (l < r)
-    {
+void mergeSort(int arr[], int l, int r) {
+    if (l < r) {
         int m = l + (r - l) / 2;
 
         mergeSort(arr, l, m);
@@ -60,14 +51,12 @@ void mergeSort(int arr[], int l, int r)
     }
 }
 
-void show(int A[], int size)
-{
+void show(int A[], int size) {
     int i;
     for (i = 0; i < size; i++) std::cout << A[i] << "\n";
 }
 
-int main()
-{
+int main() {
     int size;
     std::cout << "\nEnter the number of elements : ";
 
@@ -77,8 +66,7 @@ int main()
 
     std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i)
-    {
+    for (int i = 0; i < size; ++i) {
         std::cout << "\n";
         std::cin >> arr[i];
     }
diff --git a/sorting/non_recursive_merge_sort.cpp b/sorting/non_recursive_merge_sort.cpp
index 9086ec0ed..9d4e95f2f 100644
--- a/sorting/non_recursive_merge_sort.cpp
+++ b/sorting/non_recursive_merge_sort.cpp
@@ -22,20 +22,17 @@ void merge(Iterator, Iterator, const Iterator, char[]);
  */
 template <class Iterator>
 void non_recursive_merge_sort(const Iterator first, const Iterator last,
-                              const size_t n)
-{
+                              const size_t n) {
     // create a buffer large enough to store all elements
     // dynamically allocated to comply with cpplint
     char* buffer = new char[n * sizeof(*first)];
     // buffer size can be optimized to largest power of 2 less than n elements
     // divide the container into equally-sized segments whose length start at 1
     // and keeps increasing by factors of 2
-    for (size_t length(1); length < n; length <<= 1)
-    {
+    for (size_t length(1); length < n; length <<= 1) {
         // merge adjacent segments whose number is n / (length * 2)
         Iterator left(first);
-        for (size_t counter(n / (length << 1)); counter; --counter)
-        {
+        for (size_t counter(n / (length << 1)); counter; --counter) {
             Iterator right(left + length), end(right + length);
             merge(left, right, end, buffer);
             left = end;
@@ -56,8 +53,7 @@ void non_recursive_merge_sort(const Iterator first, const Iterator last,
  * @param b points at the buffer
  */
 template <class Iterator>
-void merge(Iterator l, Iterator r, const Iterator e, char b[])
-{
+void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
     // create 2 pointers to point at the buffer
     auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
     // move the left part of the segment
@@ -77,8 +73,7 @@ void merge(Iterator l, Iterator r, const Iterator e, char b[])
  * @param n the number of elements
  */
 template <class Iterator>
-void non_recursive_merge_sort(const Iterator first, const size_t n)
-{
+void non_recursive_merge_sort(const Iterator first, const size_t n) {
     non_recursive_merge_sort(first, first + n, n);
 }
 /// bottom-up merge sort which sorts elements in a non-decreasing order
@@ -87,19 +82,16 @@ void non_recursive_merge_sort(const Iterator first, const size_t n)
  * @param last points to 1-step past the last element
  */
 template <class Iterator>
-void non_recursive_merge_sort(const Iterator first, const Iterator last)
-{
+void non_recursive_merge_sort(const Iterator first, const Iterator last) {
     non_recursive_merge_sort(first, last, last - first);
 }
 
-int main(int argc, char** argv)
-{
+int main(int argc, char** argv) {
     int size;
     std::cout << "Enter the number of elements : ";
     std::cin >> size;
     int* arr = new int[size];
-    for (int i = 0; i < size; ++i)
-    {
+    for (int i = 0; i < size; ++i) {
         std::cout << "arr[" << i << "] = ";
         std::cin >> arr[i];
     }
diff --git a/sorting/numeric_string_sort.cpp b/sorting/numeric_string_sort.cpp
index 358cc63e3..04a12e71a 100644
--- a/sorting/numeric_string_sort.cpp
+++ b/sorting/numeric_string_sort.cpp
@@ -13,14 +13,11 @@
 #include <string>
 #include <vector>
 
-bool NumericSort(std::string a, std::string b)
-{
-    while (a[0] == '0')
-    {
+bool NumericSort(std::string a, std::string b) {
+    while (a[0] == '0') {
         a.erase(a.begin());
     }
-    while (b[0] == '0')
-    {
+    while (b[0] == '0') {
         b.erase(b.begin());
     }
     int n = a.length();
@@ -30,31 +27,27 @@ bool NumericSort(std::string a, std::string b)
     return n < m;
 }
 
-int main()
-{
+int main() {
     int n;
     std::cout << "Enter number of elements to be sorted Numerically\n";
     std::cin >> n;
 
     std::vector<std::string> v(n);
     std::cout << "Enter the string of Numbers\n";
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         std::cin >> v[i];
     }
 
     sort(v.begin(), v.end());
     std::cout << "Elements sorted normally \n";
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         std::cout << v[i] << " ";
     }
     std::cout << "\n";
 
     std::sort(v.begin(), v.end(), NumericSort);
     std::cout << "Elements sorted Numerically \n";
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         std::cout << v[i] << " ";
     }
 
diff --git a/sorting/odd_even_sort.cpp b/sorting/odd_even_sort.cpp
index 274f3033b..25f2a3712 100644
--- a/sorting/odd_even_sort.cpp
+++ b/sorting/odd_even_sort.cpp
@@ -4,16 +4,13 @@
 
 using namespace std;
 
-void oddEven(vector<int> &arr, int size)
-{
+void oddEven(vector<int> &arr, int size) {
     bool sorted = false;
-    while (!sorted)
-    {
+    while (!sorted) {
         sorted = true;
         for (int i = 1; i < size - 1; i += 2)  // Odd
         {
-            if (arr[i] > arr[i + 1])
-            {
+            if (arr[i] > arr[i + 1]) {
                 swap(arr[i], arr[i + 1]);
                 sorted = false;
             }
@@ -21,8 +18,7 @@ void oddEven(vector<int> &arr, int size)
 
         for (int i = 0; i < size - 1; i += 2)  // Even
         {
-            if (arr[i] > arr[i + 1])
-            {
+            if (arr[i] > arr[i + 1]) {
                 swap(arr[i], arr[i + 1]);
                 sorted = false;
             }
@@ -30,14 +26,12 @@ void oddEven(vector<int> &arr, int size)
     }
 }
 
-void show(vector<int> A, int size)
-{
+void show(vector<int> A, int size) {
     int i;
     for (i = 0; i < size; i++) cout << A[i] << "\n";
 }
 
-int main()
-{
+int main() {
     int size, temp;
     cout << "\nEnter the number of elements : ";
     cin >> size;
@@ -46,8 +40,7 @@ int main()
 
     cout << "\nEnter the unsorted elements : \n";
 
-    for (int i = 0; i < size; ++i)
-    {
+    for (int i = 0; i < size; ++i) {
         cin >> temp;
         arr.push_back(temp);
     }
diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
index 8bb376b24..1db6b014e 100644
--- a/sorting/quick_sort.cpp
+++ b/sorting/quick_sort.cpp
@@ -33,17 +33,14 @@
  *
  */
 
-int partition(int arr[], int low, int high)
-{
+int partition(int arr[], int low, int high) {
     int pivot = arr[high];  // taking the last element as pivot
     int i = (low - 1);      // Index of smaller element
 
-    for (int j = low; j < high; j++)
-    {
+    for (int j = low; j < high; j++) {
         // If current element is smaller than or
         // equal to pivot
-        if (arr[j] <= pivot)
-        {
+        if (arr[j] <= pivot) {
             i++;  // increment index of smaller element
             int temp = arr[i];
             arr[i] = arr[j];
@@ -62,10 +59,8 @@ int partition(int arr[], int low, int high)
  *      low --> Starting index,
  *      high --> Ending index
  */
-void quickSort(int arr[], int low, int high)
-{
-    if (low < high)
-    {
+void quickSort(int arr[], int low, int high) {
+    if (low < high) {
         int p = partition(arr, low, high);
         quickSort(arr, low, p - 1);
         quickSort(arr, p + 1, high);
@@ -73,15 +68,13 @@ void quickSort(int arr[], int low, int high)
 }
 
 // prints the array after sorting
-void show(int arr[], int size)
-{
+void show(int arr[], int size) {
     for (int i = 0; i < size; i++) std::cout << arr[i] << " ";
     std::cout << "\n";
 }
 
 /** Driver program to test above functions */
-int main()
-{
+int main() {
     int size;
     std::cout << "\nEnter the number of elements : ";
 
@@ -91,8 +84,7 @@ int main()
 
     std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i)
-    {
+    for (int i = 0; i < size; ++i) {
         std::cout << "\n";
         std::cin >> arr[i];
     }
diff --git a/sorting/radix_sort.cpp b/sorting/radix_sort.cpp
index c3b5b1629..a0fbfe99e 100644
--- a/sorting/radix_sort.cpp
+++ b/sorting/radix_sort.cpp
@@ -3,66 +3,53 @@
 #include <cstring>
 #include <iostream>
 
-void radixsort(int a[], int n)
-{
+void radixsort(int a[], int n) {
     int count[10];
     int* output = new int[n];
     memset(output, 0, n * sizeof(*output));
     memset(count, 0, sizeof(count));
     int max = 0;
-    for (int i = 0; i < n; ++i)
-    {
-        if (a[i] > max)
-        {
+    for (int i = 0; i < n; ++i) {
+        if (a[i] > max) {
             max = a[i];
         }
     }
     int maxdigits = 0;
-    while (max)
-    {
+    while (max) {
         maxdigits++;
         max /= 10;
     }
-    for (int j = 0; j < maxdigits; j++)
-    {
-        for (int i = 0; i < n; i++)
-        {
+    for (int j = 0; j < maxdigits; j++) {
+        for (int i = 0; i < n; i++) {
             int t = std::pow(10, j);
             count[(a[i] % (10 * t)) / t]++;
         }
         int k = 0;
-        for (int p = 0; p < 10; p++)
-        {
-            for (int i = 0; i < n; i++)
-            {
+        for (int p = 0; p < 10; p++) {
+            for (int i = 0; i < n; i++) {
                 int t = std::pow(10, j);
-                if ((a[i] % (10 * t)) / t == p)
-                {
+                if ((a[i] % (10 * t)) / t == p) {
                     output[k] = a[i];
                     k++;
                 }
             }
         }
         memset(count, 0, sizeof(count));
-        for (int i = 0; i < n; ++i)
-        {
+        for (int i = 0; i < n; ++i) {
             a[i] = output[i];
         }
     }
     delete[] output;
 }
 
-void print(int a[], int n)
-{
-    for (int i = 0; i < n; ++i)
-    {
+void print(int a[], int n) {
+    for (int i = 0; i < n; ++i) {
         std::cout << a[i] << " ";
     }
     std::cout << std::endl;
 }
 
-int main(int argc, char const* argv[])
-{
+int main(int argc, char const* argv[]) {
     int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
     int n = sizeof(a) / sizeof(a[0]);
     radixsort(a, n);
diff --git a/sorting/selection_sort.cpp b/sorting/selection_sort.cpp
index 7e8b0678c..3854f52e6 100644
--- a/sorting/selection_sort.cpp
+++ b/sorting/selection_sort.cpp
@@ -3,25 +3,20 @@
 #include <iostream>
 using namespace std;
 
-int main()
-{
+int main() {
     int Array[6];
     cout << "\nEnter any 6 Numbers for Unsorted Array : ";
 
     // Input
-    for (int i = 0; i < 6; i++)
-    {
+    for (int i = 0; i < 6; i++) {
         cin >> Array[i];
     }
 
     // Selection Sorting
-    for (int i = 0; i < 6; i++)
-    {
+    for (int i = 0; i < 6; i++) {
         int min = i;
-        for (int j = i + 1; j < 6; j++)
-        {
-            if (Array[j] < Array[min])
-            {
+        for (int j = i + 1; j < 6; j++) {
+            if (Array[j] < Array[min]) {
                 min = j;  // Finding the smallest number in Array
             }
         }
@@ -32,8 +27,7 @@ int main()
 
     // Output
     cout << "\nSorted Array : ";
-    for (int i = 0; i < 6; i++)
-    {
+    for (int i = 0; i < 6; i++) {
         cout << Array[i] << "\t";
     }
 }
diff --git a/sorting/shell_sort.cpp b/sorting/shell_sort.cpp
index af783eb24..eb701478d 100644
--- a/sorting/shell_sort.cpp
+++ b/sorting/shell_sort.cpp
@@ -1,31 +1,23 @@
 #include <iostream>
 
-int main()
-{
+int main() {
     int size = 10;
     int* array = new int[size];
     // Input
     std::cout << "\nHow many numbers do want to enter in unsorted array : ";
     std::cin >> size;
     std::cout << "\nEnter the numbers for unsorted array : ";
-    for (int i = 0; i < size; i++)
-    {
+    for (int i = 0; i < size; i++) {
         std::cin >> array[i];
     }
 
     // Sorting
-    for (int i = size / 2; i > 0; i = i / 2)
-    {
-        for (int j = i; j < size; j++)
-        {
-            for (int k = j - i; k >= 0; k = k - i)
-            {
-                if (array[k] < array[k + i])
-                {
+    for (int i = size / 2; i > 0; i = i / 2) {
+        for (int j = i; j < size; j++) {
+            for (int k = j - i; k >= 0; k = k - i) {
+                if (array[k] < array[k + i]) {
                     break;
-                }
-                else
-                {
+                } else {
                     int temp = array[k + i];
                     array[k + i] = array[k];
                     array[k] = temp;
@@ -36,8 +28,7 @@ int main()
 
     // Output
     std::cout << "\nSorted array : ";
-    for (int i = 0; i < size; ++i)
-    {
+    for (int i = 0; i < size; ++i) {
         std::cout << array[i] << "\t";
     }
 
diff --git a/sorting/shell_sort2.cpp b/sorting/shell_sort2.cpp
index dee8cecd7..59f204818 100644
--- a/sorting/shell_sort2.cpp
+++ b/sorting/shell_sort2.cpp
@@ -7,8 +7,7 @@
 #include <utility>
 
 template <class T>
-void show_data(T *arr, size_t LEN)
-{
+void show_data(T *arr, size_t LEN) {
     size_t i;
 
     for (i = 0; i < LEN; i++) std::cout << arr[i] << ", ";
@@ -16,8 +15,7 @@ void show_data(T *arr, size_t LEN)
 }
 
 template <class T, size_t N>
-void show_data(T (&arr)[N])
-{
+void show_data(T (&arr)[N]) {
     show_data(arr, N);
 }
 
@@ -26,17 +24,14 @@ void show_data(T (&arr)[N])
  * Mar
  **/
 template <class T>
-void shell_sort(T *arr, size_t LEN)
-{
+void shell_sort(T *arr, size_t LEN) {
     const unsigned int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1};
     const unsigned int gap_len = 8;
     size_t i, j, g;
 
-    for (g = 0; g < gap_len; g++)
-    {
+    for (g = 0; g < gap_len; g++) {
         unsigned int gap = gaps[g];
-        for (i = gap; i < LEN; i++)
-        {
+        for (i = gap; i < LEN; i++) {
             T tmp = arr[i];
 
             for (j = i; j >= gap && (arr[j - gap] - tmp) > 0; j -= gap)
@@ -48,16 +43,14 @@ void shell_sort(T *arr, size_t LEN)
 }
 
 template <class T, size_t N>
-void shell_sort(T (&arr)[N])
-{
+void shell_sort(T (&arr)[N]) {
     shell_sort(arr, N);
 }
 
 /**
  * function to compare sorting using cstdlib's qsort
  **/
-int compare(const void *a, const void *b)
-{
+int compare(const void *a, const void *b) {
     int arg1 = *static_cast<const int *>(a);
     int arg2 = *static_cast<const int *>(b);
 
@@ -71,8 +64,7 @@ int compare(const void *a, const void *b)
     //  return arg1 - arg2; // erroneous shortcut (fails if INT_MIN is present)
 }
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     int i, NUM_DATA;
 
     if (argc == 2)
diff --git a/sorting/slow_sort.cpp b/sorting/slow_sort.cpp
index e4f175af6..a3e64dba0 100644
--- a/sorting/slow_sort.cpp
+++ b/sorting/slow_sort.cpp
@@ -10,8 +10,7 @@
 
 #include <iostream>
 
-void SlowSort(int a[], int i, int j)
-{
+void SlowSort(int a[], int i, int j) {
     if (i >= j)
         return;
     int m = i + (j - i) / 2;  // midpoint, implemented this way to avoid
@@ -19,8 +18,7 @@ void SlowSort(int a[], int i, int j)
     int temp;
     SlowSort(a, i, m);
     SlowSort(a, m + 1, j);
-    if (a[j] < a[m])
-    {
+    if (a[j] < a[m]) {
         temp = a[j];  // swapping a[j] & a[m]
         a[j] = a[m];
         a[m] = temp;
@@ -30,8 +28,7 @@ void SlowSort(int a[], int i, int j)
 
 // Sample Main function
 
-int main()
-{
+int main() {
     int size;
     std::cout << "\nEnter the number of elements : ";
 
@@ -41,8 +38,7 @@ int main()
 
     std::cout << "\nEnter the unsorted elements : ";
 
-    for (int i = 0; i < size; ++i)
-    {
+    for (int i = 0; i < size; ++i) {
         std::cout << "\n";
         std::cin >> arr[i];
     }
@@ -51,8 +47,7 @@ int main()
 
     std::cout << "Sorted array\n";
 
-    for (int i = 0; i < size; ++i)
-    {
+    for (int i = 0; i < size; ++i) {
         std::cout << arr[i] << " ";
     }
 
diff --git a/sorting/swap_sort.cpp b/sorting/swap_sort.cpp
index 7d391d8a1..4cdaa57b3 100644
--- a/sorting/swap_sort.cpp
+++ b/sorting/swap_sort.cpp
@@ -6,14 +6,12 @@
 
 // Function returns the minimum number of swaps
 // required to sort the array
-int minSwaps(int arr[], int n)
-{
+int minSwaps(int arr[], int n) {
     // Create an array of pairs where first
     // element is array element and second element
     // is position of first element
     std::pair<int, int> *arrPos = new std::pair<int, int>[n];
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         arrPos[i].first = arr[i];
         arrPos[i].second = i;
     }
@@ -31,8 +29,7 @@ int minSwaps(int arr[], int n)
     int ans = 0;
 
     // Traverse array elements
-    for (int i = 0; i < n; i++)
-    {
+    for (int i = 0; i < n; i++) {
         // already swapped and corrected or
         // already present at correct pos
         if (vis[i] || arrPos[i].second == i)
@@ -42,8 +39,7 @@ int minSwaps(int arr[], int n)
         // this cycle and add in ans
         int cycle_size = 0;
         int j = i;
-        while (!vis[j])
-        {
+        while (!vis[j]) {
             vis[j] = 1;
 
             // move to next node
@@ -52,8 +48,7 @@ int minSwaps(int arr[], int n)
         }
 
         // Update answer by adding current cycle.
-        if (cycle_size > 0)
-        {
+        if (cycle_size > 0) {
             ans += (cycle_size - 1);
         }
     }
@@ -65,8 +60,7 @@ int minSwaps(int arr[], int n)
 }
 
 // program to test
-int main()
-{
+int main() {
     int arr[] = {6, 7, 8, 1, 2, 3, 9, 12};
     int n = (sizeof(arr) / sizeof(int));
     std::cout << minSwaps(arr, n);
diff --git a/sorting/tim_sort.cpp b/sorting/tim_sort.cpp
index 9645a60b1..94f5aa230 100644
--- a/sorting/tim_sort.cpp
+++ b/sorting/tim_sort.cpp
@@ -6,14 +6,11 @@ const int RUN = 32;
 
 // this function sorts array from left index to to right index which is of size
 // atmost RUN
-void insertionSort(int arr[], int left, int right)
-{
-    for (int i = left + 1; i <= right; i++)
-    {
+void insertionSort(int arr[], int left, int right) {
+    for (int i = left + 1; i <= right; i++) {
         int temp = arr[i];
         int j = i - 1;
-        while (arr[j] > temp && j >= left)
-        {
+        while (arr[j] > temp && j >= left) {
             arr[j + 1] = arr[j];
             j--;
         }
@@ -22,8 +19,7 @@ void insertionSort(int arr[], int left, int right)
 }
 
 // merge function merges the sorted runs
-void merge(int arr[], int l, int m, int r)
-{
+void merge(int arr[], int l, int m, int r) {
     // original array is broken in two parts, left and right array
     int len1 = m - l + 1, len2 = r - m;
     int *left = new int[len1], *right = new int[len2];
@@ -35,15 +31,11 @@ void merge(int arr[], int l, int m, int r)
     int k = l;
 
     // after comparing, we merge those two array in larger sub array
-    while (i < len1 && j < len2)
-    {
-        if (left[i] <= right[j])
-        {
+    while (i < len1 && j < len2) {
+        if (left[i] <= right[j]) {
             arr[k] = left[i];
             i++;
-        }
-        else
-        {
+        } else {
             arr[k] = right[j];
             j++;
         }
@@ -51,16 +43,14 @@ void merge(int arr[], int l, int m, int r)
     }
 
     // copy remaining elements of left, if any
-    while (i < len1)
-    {
+    while (i < len1) {
         arr[k] = left[i];
         k++;
         i++;
     }
 
     // copy remaining element of right, if any
-    while (j < len2)
-    {
+    while (j < len2) {
         arr[k] = right[j];
         k++;
         j++;
@@ -70,21 +60,18 @@ void merge(int arr[], int l, int m, int r)
 }
 
 // iterative Timsort function to sort the array[0...n-1] (similar to merge sort)
-void timSort(int arr[], int n)
-{
+void timSort(int arr[], int n) {
     // Sort individual subarrays of size RUN
     for (int i = 0; i < n; i += RUN)
         insertionSort(arr, i, std::min((i + 31), (n - 1)));
 
     // start merging from size RUN (or 32). It will merge to form size 64, then
     // 128, 256 and so on ....
-    for (int size = RUN; size < n; size = 2 * size)
-    {
+    for (int size = RUN; size < n; size = 2 * size) {
         // pick starting point of left sub array. We are going to merge
         // arr[left..left+size-1] and arr[left+size, left+2*size-1] After every
         // merge, we increase left by 2*size
-        for (int left = 0; left < n; left += 2 * size)
-        {
+        for (int left = 0; left < n; left += 2 * size) {
             // find ending point of left sub array
             // mid+1 is starting point of right sub array
             int mid = left + size - 1;
@@ -97,15 +84,13 @@ void timSort(int arr[], int n)
 }
 
 // utility function to print the Array
-void printArray(int arr[], int n)
-{
+void printArray(int arr[], int n) {
     for (int i = 0; i < n; i++) printf("%d  ", arr[i]);
     std::cout << std::endl;
 }
 
 // Driver program to test above function
-int main()
-{
+int main() {
     int arr[] = {5, 21, 7, 23, 19};
     int n = sizeof(arr) / sizeof(arr[0]);
     printf("Given Array is\n");
diff --git a/strings/brute_force_string_searching.cpp b/strings/brute_force_string_searching.cpp
index 5f6116e1b..9a2b5327a 100644
--- a/strings/brute_force_string_searching.cpp
+++ b/strings/brute_force_string_searching.cpp
@@ -17,18 +17,14 @@
  * @return         Index where the pattern starts in the text
  * @return         -1 if the pattern was not found.
  */
-int brute_force(const std::string &text, const std::string &pattern)
-{
+int brute_force(const std::string &text, const std::string &pattern) {
     size_t pat_l = pattern.length();
     size_t txt_l = text.length();
     int index = -1;
-    if (pat_l <= txt_l)
-    {
-        for (size_t i = 0; i < txt_l - pat_l + 1; i++)
-        {
+    if (pat_l <= txt_l) {
+        for (size_t i = 0; i < txt_l - pat_l + 1; i++) {
             std::string s = text.substr(i, pat_l);
-            if (s == pattern)
-            {
+            if (s == pattern) {
                 index = i;
                 break;
             }
@@ -44,10 +40,8 @@ const std::vector<std::vector<std::string>> test_set = {
     {"bba", "bb", "0"}, {"bbca", "c", "2"}, {"ab", "b", "1"}};
 
 /** Main function */
-int main()
-{
-    for (size_t i = 0; i < test_set.size(); i++)
-    {
+int main() {
+    for (size_t i = 0; i < test_set.size(); i++) {
         int output = brute_force(test_set[i][0], test_set[i][1]);
 
         if (std::to_string(output) == test_set[i][2])
diff --git a/strings/knuth_morris_pratt.cpp b/strings/knuth_morris_pratt.cpp
index 29e6ef834..b83cab966 100644
--- a/strings/knuth_morris_pratt.cpp
+++ b/strings/knuth_morris_pratt.cpp
@@ -26,17 +26,14 @@
  * \param[in] pattern text for which to create the partial match table
  * \returns the partial match table as a vector array
  */
-std::vector<int> getFailureArray(const std::string &pattern)
-{
+std::vector<int> getFailureArray(const std::string &pattern) {
     int pattern_length = pattern.size();
     std::vector<int> failure(pattern_length + 1);
     failure[0] = -1;
     int j = -1;
 
-    for (int i = 0; i < pattern_length; i++)
-    {
-        while (j != -1 && pattern[j] != pattern[i])
-        {
+    for (int i = 0; i < pattern_length; i++) {
+        while (j != -1 && pattern[j] != pattern[i]) {
             j = failure[j];
         }
         j++;
@@ -52,16 +49,13 @@ std::vector<int> getFailureArray(const std::string &pattern)
  * \returns `true` if pattern was found
  * \returns `false` if pattern was not found
  */
-bool kmp(const std::string &pattern, const std::string &text)
-{
+bool kmp(const std::string &pattern, const std::string &text) {
     int text_length = text.size(), pattern_length = pattern.size();
     std::vector<int> failure = getFailureArray(pattern);
 
     int k = 0;
-    for (int j = 0; j < text_length; j++)
-    {
-        while (k != -1 && pattern[k] != text[j])
-        {
+    for (int j = 0; j < text_length; j++) {
+        while (k != -1 && pattern[k] != text[j]) {
             k = failure[k];
         }
         k++;
@@ -72,28 +66,21 @@ bool kmp(const std::string &pattern, const std::string &text)
 }
 
 /** Main function */
-int main()
-{
+int main() {
     std::string text = "alskfjaldsabc1abc1abc12k23adsfabcabc";
     std::string pattern = "abc1abc12l";
 
-    if (kmp(pattern, text) == true)
-    {
+    if (kmp(pattern, text) == true) {
         std::cout << "Found" << std::endl;
-    }
-    else
-    {
+    } else {
         std::cout << "Not Found" << std::endl;
     }
 
     text = "abcabc";
     pattern = "bca";
-    if (kmp(pattern, text) == true)
-    {
+    if (kmp(pattern, text) == true) {
         std::cout << "Found" << std::endl;
-    }
-    else
-    {
+    } else {
         std::cout << "Not Found" << std::endl;
     }
 
diff --git a/strings/rabin_karp.cpp b/strings/rabin_karp.cpp
index 5baaaf615..018ff5632 100644
--- a/strings/rabin_karp.cpp
+++ b/strings/rabin_karp.cpp
@@ -21,11 +21,9 @@
  * \param[in] n length of substring to hash
  * \returns hash integer
  */
-int64_t create_hash(const std::string& s, int n)
-{
+int64_t create_hash(const std::string& s, int n) {
     int64_t result = 0;
-    for (int i = 0; i < n; ++i)
-    {
+    for (int i = 0; i < n; ++i) {
         result += (int64_t)(s[i] * (int64_t)pow(PRIME, i));
     }
     return result;
@@ -41,8 +39,7 @@ int64_t create_hash(const std::string& s, int n)
  * \returns new hash integer
  */
 int64_t recalculate_hash(const std::string& s, int old_index, int new_index,
-                         int64_t old_hash, int patLength)
-{
+                         int64_t old_hash, int patLength) {
     int64_t new_hash = old_hash - s[old_index];
     new_hash /= PRIME;
     new_hash += (int64_t)(s[new_index] * (int64_t)pow(PRIME, patLength - 1));
@@ -60,16 +57,12 @@ int64_t recalculate_hash(const std::string& s, int old_index, int new_index,
  * @note can this be replaced by std::string::compare?
  */
 bool check_if_equal(const std::string& str1, const std::string& str2,
-                    int start1, int end1, int start2, int end2)
-{
-    if (end1 - start1 != end2 - start2)
-    {
+                    int start1, int end1, int start2, int end2) {
+    if (end1 - start1 != end2 - start2) {
         return false;
     }
-    while (start1 <= end1 && start2 <= end2)
-    {
-        if (str1[start1] != str2[start2])
-        {
+    while (start1 <= end1 && start2 <= end2) {
+        if (str1[start1] != str2[start2]) {
             return false;
         }
         start1++;
@@ -86,19 +79,16 @@ bool check_if_equal(const std::string& str1, const std::string& str2,
  *  @return -1 if pattern not found
  */
 
-int rabin_karp(const std::string& str, const std::string& pat)
-{
+int rabin_karp(const std::string& str, const std::string& pat) {
     int64_t pat_hash = create_hash(pat, pat.size());
     int64_t str_hash = create_hash(str, pat.size());
-    for (int i = 0; i <= str.size() - pat.size(); ++i)
-    {
+    for (int i = 0; i <= str.size() - pat.size(); ++i) {
         if (pat_hash == str_hash &&
-            check_if_equal(str, pat, i, i + pat.size() - 1, 0, pat.size() - 1))
-        {
+            check_if_equal(str, pat, i, i + pat.size() - 1, 0,
+                           pat.size() - 1)) {
             return i;
         }
-        if (i < str.size() - pat.size())
-        {
+        if (i < str.size() - pat.size()) {
             str_hash =
                 recalculate_hash(str, i, i + pat.size(), str_hash, pat.size());
         }
@@ -107,8 +97,7 @@ int rabin_karp(const std::string& str, const std::string& pat)
 }
 
 /** Main function */
-int main(void)
-{
+int main(void) {
     assert(rabin_karp("helloWorld", "world") == -1);
     assert(rabin_karp("helloWorld", "World") == 5);
     assert(rabin_karp("this_is_c++", "c++") == 8);

From 3ab76459cd1e792636d7b55787ea30423efa038a Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Sat, 30 May 2020 04:02:28 +0000
Subject: [PATCH 289/290] updating DIRECTORY.md

---
 DIRECTORY.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 334538685..21f1a0c61 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,3 +1,4 @@
+# List of all files
 
 ## Backtracking
   * [Graph Coloring](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/backtracking/graph_coloring.cpp)
@@ -77,7 +78,7 @@
   * [Connected Components](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/connected_components.cpp)
   * [Connected Components With Dsu](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/connected_components_with_dsu.cpp)
   * [Dfs](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/dfs.cpp)
-  * [Dfs With Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/DFS_with_stack.cc)
+  * [Dfs With Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/dfs_with_stack.cpp)
   * [Dijkstra](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/dijkstra.cpp)
   * [Kosaraju](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/kosaraju.cpp)
   * [Kruskal](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/graph/kruskal.cpp)

From 642c7b7cb1de14efa2be031213139593ad5df212 Mon Sep 17 00:00:00 2001
From: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
Date: Sat, 30 May 2020 00:08:33 -0400
Subject: [PATCH 290/290] fix diff filename

---
 .github/workflows/awesome_forkflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/awesome_forkflow.yml b/.github/workflows/awesome_forkflow.yml
index 11e585dee..05094bdd1 100644
--- a/.github/workflows/awesome_forkflow.yml
+++ b/.github/workflows/awesome_forkflow.yml
@@ -146,7 +146,7 @@ jobs:
       - run: git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
       - run: git pull
       - run: git diff --diff-filter=dr --name-only origin/master > git_diff.txt
-      - run: echo "Files changed-- `cat diff.txt`"
+      - run: echo "Files changed-- `cat git_diff.txt`"
       - name: cpplint_modified_files
         shell: python
         run: |