//include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>

#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>

#include <stdexcept>

using namespace std;

//conversion
//------------------------------------------
inline int toint(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class t> inline string tostring(t x) { ostringstream sout; sout << x; return sout.str(); }

//debug
#define dump(x)  cerr << #x << " = " << (x) << endl
#define debug(x) cerr << #x << " = " << (x) << " (l" << __line__ << ")" << " " << __file__ << endl

// type alias
using ll = long long;
using ull = unsigned long long;

inline bool isPower2(ull a)
{
	if (a == 0)
	{
		return false;
	}
	return !(a & (a - 1));
}

inline unsigned getMaxEffectiveBit(ull a)
{
	ll index = 0;
	for (; a != 0; a >>= 1)
	{
		++index;
	}
	return index;
}

// computational complexity: o(log(max(a, b))) 
inline ull getGcd(ull a, ull b)
{
	if (b == 0)
	{
		return a;
	}
	return getGcd(b, a % b);
}

// computational complexity: o(log(max(a, b))) 
template<class ll>
inline pair<ll, ll> getBezoutsIdentitySolution(ll a, ll b)
{
	if (b == 0)
	{
		return { 1, 0 };
	}
	auto sol = getBezoutsIdentitySolution(b, a % b);
	return { sol.second, sol.first - (a / b) * sol.second };
}

template<class Integer>
inline Integer getPower(Integer base, unsigned exponential)
{
	Integer res = 1;
	while (exponential >= 1)
	{
		if (exponential & 1)
		{
			res *= base;
		}
		base = base * base;
		exponential >>= 1;
	}

	return res;
}



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

	ll N;
	cin >> N;
	
	vector<bool> arePrimes(N + 1, true);
	arePrimes[0] = arePrimes[1] = false;
	for (ll n = 2; n <= sqrt(N); ++n)
	{
		if (!arePrimes[n])
		{
			continue;
		}
		for (ll i = 2; n * i <= N; ++i)
		{
			arePrimes[n * i] = false;
		}
	}

	map<ll, ll> primeCount;
	for (ll n = 2; n <= N; ++n)
	{
		auto factor = n;
		for (ll i = 2; i <= n; ++i)
		{
			if (!arePrimes[i])
			{
				continue;
			}
			while (factor % i == 0)
			{
				if (primeCount.count(i) == 0)
				{
					primeCount[i] = 0;
				}
				++primeCount[i];
				factor /= i;
			}
		}
	}

	ll res = 0;
	{
		// 75
		ll num75 = 0;
		for (auto iter = primeCount.begin(); iter != primeCount.end(); ++iter)
		{
			if (iter->second >= 74)
			{
				++num75;
			}
		}
		res += num75;
	}

	{
		// 25, 3
		ll num25 = 0, num3 = 0;
		for (auto iter = primeCount.begin(); iter != primeCount.end(); ++iter)
		{
			if (iter->second >= 24)
			{
				++num25;
			}
			if (iter->second >= 2)
			{
				++num3;
			}
		}
		res += (num3 - num25) * num25 + num25 * (num25 - 1);
	}
	
	{
		// 15, 5
		ll num15 = 0, num5 = 0;
		for (auto iter = primeCount.begin(); iter != primeCount.end(); ++iter)
		{
			if (iter->second >= 14)
			{
				++num15;
			}
			if (iter->second >= 4)
			{
				++num5;
			}
		}
		res += (num5 - num15) * num15 + num15 * (num15 - 1);
	}

	{
		// 5, 5, 3
		ll num5 = 0, num3 = 0;
		for (auto iter = primeCount.begin(); iter != primeCount.end(); ++iter)
		{
			if (iter->second >= 4)
			{
				++num5;
			}
			if (iter->second >= 2)
			{
				++num3;
			}
		}
		res += (num3 - num5) * num5 * (num5 - 1) / 2 + num5 * (num5 - 1) * (num5 - 2) / 2;
	}

	cout << res << endl;

	return 0;
}


Measured memory_bytes: 256