Problem:
Score : 400 points

Problem Statement

You are given an integer N. Among the divisors of N! (= 1 \times 2 \times ... \times N), how many Shichi-Go numbers (literally "Seven-Five numbers") are there?

Here, a Shichi-Go number is a positive integer that has exactly 75 divisors.

Note

When a positive integer A divides a positive integer B, A is said to a divisor of B.
For example, 6 has four divisors: 1, 2, 3 and 6.

Constraints

1 \leq N \leq 100

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

Print the number of the Shichi-Go numbers that are divisors of N!.

Sample Input 1

9

Sample Output 1

0

There are no Shichi-Go numbers among the divisors of 9! = 1 \times 2 \times ... \times 9 = 362880.

Sample Input 2

10

Sample Output 2

1

There is one Shichi-Go number among the divisors of 10! = 3628800: 32400.

Sample Input 3

100

Sample Output 3

543

Solution in Rust (1.15.1) (judge verdict: Accepted)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use competitive::prelude::*;

// 素因数分解O(√n)
fn prime_factor(mut n: i64) -> BTreeMap<i64, i64> {
    let mut res = BTreeMap::new();
    let mut i = 2;
    while i * i <= n {
        let mut v = 0;
        while n % i == 0 {
            v += 1;
            n /= i;
        }
        if v > 0 {
            res.insert(i, v);
        }
        i += 1;
    }
    if n != 1 {
        res.insert(n, 1);
    }
    return res;
}

pub fn binom_knuth(n: i64, k: i64) -> i64 {
    (0..n + 1).rev().zip(1..k + 1).fold(1, |mut r, (n, d)| {
        r *= n;
        r /= d;
        r
    })
}

fn count(pf: &BTreeMap<i64, i64>, n: i64) -> i64 {
    let mut c = 0;
    for (_, &v) in pf {
        if v >= n {
            c += 1;
        }
    }
    c
}

#[proconio::fastout]
fn main() {
    input! {
        n : i64,
    }
    let mut pf: BTreeMap<i64, i64> = BTreeMap::new();
    let mut i = 2;
    while i <= n {
        for (k, v) in prime_factor(i) {
            let a = *pf.entry(k).or_default();
            pf.insert(k, a + v);
        }
        i += 1;
    }
    // dbg!(&pf);
    let mut ans = binom_knuth(count(&pf, 4), 2) * binom_knuth(count(&pf, 2) - 2, 1);
    ans += binom_knuth(count(&pf, 14), 1) * binom_knuth(count(&pf, 4) - 1, 1);
    ans += binom_knuth(count(&pf, 24), 1) * binom_knuth(count(&pf, 2) - 1, 1);
    ans += binom_knuth(count(&pf, 74), 1);
    echo!(ans);
}
*/

fn main() {
    let exe = "/tmp/binFBB19CDA";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";