#include <bits/stdc++.h>
using namespace std;

#define CPP_STR(x) CPP_STR_I(x)
#define CPP_CAT(x,y) CPP_CAT_I(x,y)
#define CPP_STR_I(args...) #args
#define CPP_CAT_I(x,y) x ## y

using i8  = int8_t;
using u8  = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;

using f32 = float;
using f64 = double;

#define FOR(i, start, end) for(i64 i = (start), CPP_CAT(i,xxxx_end)=(end); i < CPP_CAT(i,xxxx_end); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) for(i64 i = 1; i <= n; ++i)
#define RREP(i, n) for(i64 i = n - 1; i >= 0 ; --i)
#define RREPS(i, n) for(i64 i = n; i >= 1; --i)

#define ALL(f,c,...) (([&](decltype((c)) cccc) { return (f)(std::begin(cccc), std::end(cccc), ## __VA_ARGS__); })(c))

#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

#define pb push_back
#define mp make_pair
#define F first
#define S second

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

template<typename C>
i64 SIZE(const C& c) { return static_cast<i64>(c.size()); }

template<typename T, size_t N>
i64 SIZE(const T (&)[N]) { return static_cast<i64>(N); }


struct ProconInit {
    static constexpr int IOS_PREC = 15;
    static constexpr bool AUTOFLUSH = false;

    ProconInit() {
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(IOS_PREC);
        if(AUTOFLUSH)
            cout << unitbuf;
    }
} PROCON_INIT;


struct Sieve {
    i64 n;
    vector<i64> f, primes;
    using P = pair<i64, i64>;

    Sieve(i64 n = 1) : n(n), f(n + 1) {
        f[0] = f[1] = -1;
        for (i64 i = 2; i <= n; i++) {
            if (f[i]) continue;
            primes.push_back(i);
            f[i] = i;
            for (i64 j = i * i; j <= n; j += i) {
                if (f[j] == 0) f[j] = i;
            }
        }
    }

    bool is_prime(i64 x) {
        return f[x] == x;
    }

    vector<i64> factor_list(i64 x) {
        vector<i64> res;
        while (x != 1) {
            res.push_back(f[x]);
            x /= f[x];
        }
        return res;
    }

    vector<P> factor(i64 x) {
        vector<i64> fl = factor_list(x);
        if (fl.size() == 0) return {};
        vector<P> res(1, P(fl[0], 0));
        for (i64 p : fl) {
            if (res.back().first == p) {
                res.back().second++;
            } else {
                res.emplace_back(p, 1);
            }
        }
        return res;
    }
};

#define MAX_N 100
using P = pair<i64, i64>;

int main() {
    i64 N; cin >> N;
    // xの約数の個数: x = 2^a * 3^b * ...
    // と素因数分解できるとき、約数の個数は
    // 1~aから一つ選ぶ、1~bから1つ選ぶことを繰り返して、
    // a * b * ...
    if (N == 1) {
        cout << 0 << endl;
        return 0;
    }

    vector<i64> n_factored(N + 1, 0);
    Sieve sieve(N);
    for (i64 i = 2; i <= N; i++) {
        vector<P> factor = sieve.factor(i);
        for (P p : factor) {
            n_factored[p.first] += p.second;
        }
    }

    unordered_map<i64, i64> mp;
    REPS(i, N) {
        if (n_factored[i] == 0) continue;
        if (n_factored[i] >= 2) mp[2] += 1;
        if (n_factored[i] >= 4) mp[4] += 1;
        if (n_factored[i] >= 14) mp[14] += 1;
        if (n_factored[i] >= 24) mp[24] += 1;
        if (n_factored[i] >= 74) mp[74] += 1;
    }

    i64 cnt = 0;
    cnt += mp[74];
    cnt += mp[24] * (mp[2] - 1);
    cnt += mp[14] * (mp[4] - 1);
    cnt += (mp[4] * (mp[4] - 1)) / 2 * (mp[2] - 2);
    cout << cnt << endl;

    return 0;
}

Measured memory_bytes: 256