#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cstdint>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <cstdlib>
#include <sstream>
#include <functional>

#include <boost/range/irange.hpp>
using boost::irange;

#include <boost/utility/string_ref.hpp>
using string_view = boost::string_ref;

#include <boost/function_output_iterator.hpp>


using namespace std;

template<class T, size_t N, class F>
struct compare_n
{
    F f;
    bool operator() (const T& t1, const T& t2)
    {
        return f(get<N>(t1), get<N>(t2));
    }
};
 
template<size_t N, class T>
auto make_less_n(const T&)
{
    using t = typename T::value_type;
    using less = std::less<typename tuple_element<N, t>::type>;
    return compare_n<t, N, less>();
}

template<class T>
T digit(T x)
{
    return static_cast<T>(floor(log10(x)+1));
}

int64_t ipow(int64_t x, int64_t y)
{
    return static_cast<int64_t>(pow(x, y));
}

struct edge_t {
    int a,b;
};

vector<int> neighbour(const vector<edge_t>& edges, int k)
{
    vector<int> neighbour_k;
    neighbour_k.reserve(edges.size());
    
    for(const auto& e : edges)
    {
        if(e.a == k) neighbour_k.push_back(e.b);
        else if(e.b == k) neighbour_k.push_back(e.a);
    }
    
    sort(begin(neighbour_k), end(neighbour_k));
    
    return neighbour_k;
}

int64_t conbination(int64_t n, int64_t k)
{
    if(k == 1 || k == n - 1) return n;
    if(k == 0 || k == n) return 1;
    int64_t c = 1;
    for(int64_t i = 1; i <= k; ++i)
    {
        c *= (n + 1 - i) / i;
    }
    return c;
}

int main()
{
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int n;
    cin >> n;
    
    const vector<int> primes = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97};
    vector<int> factor_exp(primes.size());
    for(int k : irange(2, n+1))
    {
        for(int ip : irange(0, (int)primes.size()))
        {
            const int p = primes[ip];
            if(k < p) break;
            while(k % p == 0)
            {
                factor_exp[ip]++;
                k /= p;
            }
            
        }
    }
    /*
    cout << n << "! = ";
    for(int ip : irange(0, (int)primes.size()))
    {
        if(factor_exp[ip] == 0) break;
        if(factor_exp[ip] == 1) cout << primes[ip] << " * ";
        else cout << primes[ip] << '^' << factor_exp[ip] << " * ";
    }
    cout << "1\n";
    */
    int count = 0;
    // 75 = 5*5*3 = 15*5 = 25*3
    const int count_over_2 = count_if(begin(factor_exp), end(factor_exp), [](int x){ return x >= 2; });
    const int count_over_4 = count_if(begin(factor_exp), end(factor_exp), [](int x){ return x >= 4; });
    const int count_over_14 = count_if(begin(factor_exp), end(factor_exp), [](int x){ return x >= 14; });
    const int count_over_24 = count_if(begin(factor_exp), end(factor_exp), [](int x){ return x >= 24; });
    const int count_over_74 = count_if(begin(factor_exp), end(factor_exp), [](int x){ return x >= 74; });
    /*
    cout << "#2 : " << count_over_2 << '\n';
    cout << "#4 : " << count_over_4 << '\n';
    cout << "#14 : " << count_over_14 << '\n';
    cout << "#24: " << count_over_24 << '\n';
    cout << "#74: " << count_over_74 << '\n';
    */
    // 5*5*3
    count += count_over_4 * (count_over_4 - 1) * (count_over_2 - 2) / 2;
    
    // 15*5
    count += count_over_14 * (count_over_4 - 1);

    // 25*3
    count += count_over_24 * (count_over_2 - 1);
    
    // 75
    count += count_over_74;
    
    cout << count << '\n';
    
    return 0;
}



Measured memory_bytes: 256