// Original C++ solution (slower):
#include <bits/stdc++.h>



#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)

#define RFOR(i,a) for(int i=(a); i >= 0; --i)

#define FOE(i,a) for(auto i : a)

#define ALL(c) (c).begin(), (c).end()

#define RALL(c) (c).rbegin(), (c).rend()

#define DUMP(x)  cerr << #x << " = " << (x) << endl;

#define SUM(x) std::accumulate(ALL(x), 0LL)

#define MIN(v) *std::min_element(v.begin(), v.end())

#define MAX(v) *std::max_element(v.begin(), v.end())

#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())

#define BIT_ON(bit, i) (bit & (1LL << i))

#define BIT_COUNT(bit) (__builtin_popcount(bit))



typedef long long LL;

template<typename T> using V = std::vector<T>;

template<typename T> using VV = std::vector<std::vector<T>>;

template<typename T> using VVV = std::vector<std::vector<std::vector<T>>>;

template<typename T> using VVVV = std::vector<std::vector<std::vector<std::vector<T>>>>;



template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }

template<class T> inline void print(T x) { std::cout << x << std::endl; }

template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }

template<class T> inline void print_2vec(const std::vector<std::vector<T>> &v) { for (int i = 0; i < v.size(); ++i) { for (int j = 0; j < v[0].size(); ++j) { if (j != 0) { std::cout << " "; } std::cout << std::setw(13) << std::left << v[i][j]; } std::cout << "\n";}}

template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }

template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }

template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

template<typename T> T &chmin(T &a, const T &b) { return a = std::min(a, b); }

template<typename T> T &chmax(T &a, const T &b) { return a = std::max(a, b); }

template<class T> inline std::vector<T> unique(std::vector<T> v) { sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end()); return v; }

// 初項s, 交差dのn個の数列の和

long long sum_of_arithmetic_progression(long long s, long long d, long long n) { return n * (2 * s + (n - 1) * d) / 2; }



const int INF = 1 << 30;

const double EPS = 1e-9;

const std::string YES = "YES", Yes = "Yes", NO = "NO", No = "No";

const std::vector<int> dy4 = {0, -1, 0, 1}, dx4 = {1, 0, -1, 0};

const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };



using namespace std;



// nを素因数分解する(O(n^(1/2)))

// primeFactorDecomposition(12) : {2:2, 3:1}

map<int, int> primeFactorDecomposition(int n) {

    map<int, int> m;

    while (n > 1) {

        bool findFactor = false;

        for(int i = 2; i * i <= n; ++i) {

            if (n % i == 0) {

                m[i]++;

                n /= i;

                findFactor = true;

                break;

            }

        }

        if (!findFactor) {

            m[n]++;

            break;

        }

    }

    return m;

}



int main() {

	cin.tie(0);

	ios::sync_with_stdio(false);



	int N;

	cin >> N;



	V<int> v(100, 0);

	FOR(x, 1, N + 1) {

		auto a = primeFactorDecomposition(x);

		FOE(p, a) {

			v.at(p.first) += p.second;

		}

	}



	int ans = 0;

	FOR(i, 0, v.size()) {

		if (v[i] >= 74) {

			ans++;

		}

	}



	FOR(i, 0, v.size()) {

		FOR(j, 0, v.size()) {

			if (i == j) {

				continue;

			}

			// 3, 25

			if (v[i] >= 2 and v[j] >= 24) {

				ans++;

			}

			// 5, 15

			if (v[i] >= 4 and v[j] >= 14) {

				ans++;

			}

		}

	}



	FOR(i, 0, v.size()) {

		FOR(j, 0, v.size()) {

			FOR(k, j + 1, v.size()) {

				if (i == j or i == k) {

					continue;

				}

				// 3, 5, 5

				if (v[i] >= 2 and v[j] >= 4 and v[k] >= 4) {

					ans++;

				}

			}

		}

	}



	print(ans);



	return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>



#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)

#define RFOR(i,a) for(int i=(a); i >= 0; --i)

#define FOE(i,a) for(auto i : a)

#define ALL(c) (c).begin(), (c).end()

#define RALL(c) (c).rbegin(), (c).rend()

#define DUMP(x)  cerr << #x << " = " << (x) << endl;

#define SUM(x) std::accumulate(ALL(x), 0LL)

#define MIN(v) *std::min_element(v.begin(), v.end())

#define MAX(v) *std::max_element(v.begin(), v.end())

#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())

#define BIT_ON(bit, i) (((bit >> i) & 1) > 0)



typedef long long LL;

template<typename T> std::vector<T> make_v(size_t a){return std::vector<T>(a);}

template<typename T,typename... Ts> auto make_v(size_t a, Ts... ts){ return std::vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));}    // C++14

template<typename T,typename V> typename std::enable_if<std::is_class<T>::value==0>::type fill_v(T &t,const V &v){t=v;}

template<typename T,typename V> typename std::enable_if<std::is_class<T>::value!=0>::type fill_v(T &t,const V &v){for(auto &e:t) fill_v(e,v);}

template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }

template<class T> inline void print(T x) { std::cout << x << std::endl; }

template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }

template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }

template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }

template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

template<typename T> T &chmin(T &a, const T &b) { return a = std::min(a, b); }

template<typename T> T &chmax(T &a, const T &b) { return a = std::max(a, b); }



template<class T> inline std::vector<T> unique(std::vector<T> v) {

    sort(v.begin(), v.end());

    v.erase(unique(v.begin(), v.end()), v.end());

    return v;

}

// 初項s, 交差dのn個の数列の和

long long sum_of_arithmetic_progression(long long s, long long d, long long n) {

    return n * (2 * s + (n - 1) * d) / 2;

}



const int INF = 1 << 30;

const double EPS = 1e-9;

const long double PI = acos(-1.0);

const std::vector<int> dy4 = {0, -1, 0, 1}, dx4 = {1, 0, -1, 0};

const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };





using namespace std;



// nを素因数分解する(O(n^(1/2)))

// primeFactorDecomposition(12) : {2:2, 3:1}

map<int, int> primeFactorDecomposition(int n) {

    map<int, int> m;

    while (n > 1) {

        bool findFactor = false;

        for(int i = 2; i * i <= n; ++i) {

            if (n % i == 0) {

                m[i]++;

                n /= i;

                findFactor = true;

                break;

            }

        }

        if (!findFactor) {

            m[n]++;

            break;

        }

    }

    return m;

}





int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    int N;

    cin >> N;



    map<int, int> pf;

    FOR(i, 1, N + 1) {

        auto t = primeFactorDecomposition(i);

        FOE(p, t) {

            pf[p.first] += p.second;

        }

    }



    auto v = make_v<int>(0);

    FOE(p, pf) {

        v.emplace_back(p.second);

    }

    sort(ALL(v));



    LL ans = 0;

    FOR(i, 0, v.size()) {

        FOR(j, 0, v.size()) {

            if (i == j) {

                continue;

            }

            if (v[i] >= 4 and v[j] >= 14) {

                ans++;

            }

            if (v[i] >= 2 and v[j] >= 24) {

                ans++;

            }

        }

        if (v[i] >= 74) {

            ans++;

        }

    }

    

    FOR(i, 0, v.size()) {

        FOR(j, 0, v.size()) {

            FOR(k, j + 1, v.size()) {

                if (i == j or i == k or j == k) {

                    continue;

                }

                if (v[i] >= 2 and v[j] >= 4 and v[k] >= 4) {

                    ans++;

                }

            }

        }

    }



    print(ans);



    return 0;

}




// Fastest known solution for this problem: