import std.stdio, std.string, std.conv;
import std.range, std.algorithm, std.array, std.typecons, std.container;
import std.math, std.numeric, core.bitop;


void main() {
    int n;
    scan(n);

    auto ps = eratos(100);

    debug {
        //writeln(ps);
    }

    auto cnt = new int[](n + 1);

    foreach (i ; 2 .. n + 1) {
        debug {
            //writeln(i);
        }
        foreach (p ; ps) {
            while (i % p == 0) {
                i /= p;
                cnt[p]++;
            }
        }

        debug {
            //writeln(cnt);
        }
    }

    debug {
        //writeln(cnt);
    }

    auto cs = cnt.filter!"a > 0".array.sort!();

    debug {
        writeln(cs);
    }

    auto m = cs.length.to!int;

    long ans;

    foreach (i ; 0 .. m) {
        if (cs[i] >= 2) {
            auto fu = cs.upperBound(3).length.to!int;
            if (cs[i] > 3) {
                fu--;
            }
            fu = max(fu, 0);
            ans += 1L * fu * (fu - 1) / 2;

            auto cu = cs.upperBound(23).length.to!int;
            if (cs[i] > 23) {
                cu--;
            }
            cu = max(cu, 0);
            ans += cu;
        }

        if (cs[i] >= 4) {
            auto fu = cs.upperBound(13).length.to!int;
            if (cs[i] > 13) {
                fu--;
            }
            fu = max(fu, 0);
            ans += fu;
        }

        if (cs[i] >= 74) {
            ans++;
        }
    }

    writeln(ans);
}

int[] eratos(int n) {
    auto s = new bool[](n);
    s[] = true;
    s[0] = s[1] = false;

    for (int p = 2; p*p < n; p++) {
        if (s[p]) {
            for (int q = p*p; q < n; q += p) {
                s[q] = false;
            }
        }
    }

    return iota(n).filter!(i => s[i]).array;
}
























void scan(T...)(ref T args) {
    import std.stdio : readln;
    import std.algorithm : splitter;
    import std.conv : to;
    import std.range.primitives;

    auto line = readln().splitter();
    foreach (ref arg; args) {
        arg = line.front.to!(typeof(arg));
        line.popFront();
    }
    assert(line.empty);
}


void fillAll(R, T)(ref R arr, T value) {
    static if (is(typeof(arr[] = value))) {
        arr[] = value;
    }
    else {
        foreach (ref e; arr) {
            fillAll(e, value);
        }
    }
}