#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
#define int ll

#define REP(i,n) for(int i=0;i<n;++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 0
#  define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#  define DBG(fmt, ...)
#endif

const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const double DINF = std::numeric_limits<double>::infinity();
const int MOD = 1000000007;
#define MAX_N 100010

// 素因数分解
// map -> first: 素数 second: first の数
map<int, int> prime_factor(int n) {
    map<int, int> res;
    for(int i = 2; i * i <= n; ++i) {
        while(n % i == 0) {
            ++res[i];
            n /= i;
        }
    }
    if(n != 1) { res[n] = 1; }
    return res;
}

int prime[MAX_N];           // i 番目の素数
bool is_prime[MAX_N + 1];   // is_prime[i] が true なら i は素数

// prime と is_prime のテーブルを [0, n] の範囲で作成
// n 以下の素数の数を返す
int sieve(int n) {
    int p = 0;
    for(int i = 0; i <= n; ++i) {
        is_prime[i] = true;
    }
    is_prime[0] = is_prime[1] = false;
    for(int i = 1; i <= n; ++i) {
        if(is_prime[i]) {
            prime[p++] = i;
            for(int j = 2 * i; j <= n; j += i) {
                is_prime[j] = false;
            }
        }
    }
    return p;
}

ll N;
vector<ll> prime_v;   // [1, 100] の範囲の素数

signed main()
{
    cin >> N;

    // N! を素因数分解した結果を格納する
    map<int, int> npf;
    for(int i = 2; i <= N; ++i) {
        map<int, int> ret = prime_factor(i);
        for(auto& r : ret) {
            npf[r.first] += r.second;
        }
    }

    for(auto& tmp : npf) {
        DBG("%lld^%lld ", tmp.first, tmp.second);
    }
    DBG("\n");

    // prime_v の作成
    int prime_v_size = sieve(100);
    prime_v.assign(prime_v_size, 0);
    REP(i, prime_v_size) {
        prime_v[i] = prime[i];
    }

    // 75数は 素因数分解した結果がある特定のパターンになったものである
    ll ans = 0;
    // X^2 * Y^4 * Z^4 のパターン
    for(int x = 0; x < prime_v.size(); ++x) {
        for(int y = 0; y < prime_v.size(); ++y) {
            if(x == y) { continue; }
            for(int z = y + 1; z < prime_v.size(); ++z) {
                if(x == z || y == z) { continue; }
                if(npf[prime_v[x]] >= 2 && npf[prime_v[y]] >= 4 && npf[prime_v[z]] >= 4) {
                    //DBG("npf[%lld]: %lld npf[%lld]: %lld npf[%lld]: %lld\n",
                    //        prime_v[x], npf[prime_v[x]],
                    //        prime_v[y], npf[prime_v[y]],
                    //        prime_v[z], npf[prime_v[z]]
                    //        );
                    ans++;
                }
            }
        }
    }
    // X^2 * Y^24 のパターン
    // X^4 * Y^14 のパターン
    for(int x = 0; x < prime_v.size(); ++x) {
        for(int y = 0; y < prime_v.size(); ++y) {
            if(x == y) { continue; }
            if(npf[prime_v[x]] >= 2 && npf[prime_v[y]] >= 24) {
                ans++;
            }
            if(npf[prime_v[x]] >= 4 && npf[prime_v[y]] >= 14) {
                //DBG("npf[%lld]: %lld npf[%lld]: %lld\n",
                //        prime_v[x], npf[prime_v[x]],
                //        prime_v[y], npf[prime_v[y]]
                //   );
                ans++;
            }
        }
    }
    // X^74 のパターン
    for(int x = 0; x < prime_v.size(); ++x) {
        if(npf[prime_v[x]] >= 74) {
            ans++;
            //DBG("npf[%lld]: %lld\n",
            //        prime_v[x], npf[prime_v[x]]
            //   );
        }
    }

    printf("%lld\n", ans);
    return 0;
}


Measured memory_bytes: 256