Самый быстрый алгоритм Факториала

int ProdTree(int l, int r)
{
    if (l > r)
        return 1;
    if (l == r)
         return l;
    if (r - l == 1)
        return (int)l * r;
    int m = (l + r) / 2;
    return ProdTree(l, m) * ProdTree(m + 1, r);
}
        
int FactTree(int n)
{
    if (n < 0)
        return 0;
    if (n == 0)
        return 1;
    if (n == 1 || n == 2)
        return n;
    return ProdTree(2, n);
}

#include <iostream>
#include <unordered_map>
 
int main()
{
    std::unordered_map<int, int> factorials
    {
        {0, 1}, 
        {1, 1}, 
        {2, 2}, 
        {3, 6}, 
        {4, 24}, 
        {5, 120}, 
        {6, 720}, 
        {7, 5040}, 
        {8, 40320}, 
        {9, 362880}, 
        {10, 3628800}, 
        {11, 39916800}, 
        {12, 479001600}, 
        {13, 6227020800}, 
        {14, 87178291200}, 
        {15, 1307674368000}
    };
    
    int n{};
    
    std::cin >> n;
    
    std::cout << factorials[n];
}

#include <iostream>
#include <stdint.h>
 
namespace Constants {
    const unsigned long long FactorialSize = 32;
}
 
template<int t> struct Elem {
    static const unsigned long long value = t * Elem<t - 1>::value;
};
template<> struct Elem<0> {
    static const unsigned long long value = 0;
};
template<> struct Elem<1> {
    static const unsigned long long value = 1;
};
template<int r, int t> struct Table : Table<r + 1, t - 1> {
    Table() { values[t] = Elem<t>::value; }
};
template<int r> struct Table<r, 0> {
    unsigned long long values[r + 1];
    Table() { values[0] = Elem<0>::value; }
    const unsigned long long& operator[](int i) const { return values[i]; }
};
 
typedef Table<0, Constants::FibSize> Fibonachi;
 
int main(int argc, char *argv[]) {
    Fibonachi fArray;
 
    std::cout << sizeof(unsigned long long) << std::endl;
 
    for (size_t i(0); i < Constants::FactorialSize; ++i)
        std::cout << fArray[i] << std::endl;
 
 
 
    std::cin.ignore();
    return 0;
}