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)

use std::io::*;
use std::str::FromStr;

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn calc(depth: usize, cnt: usize, cnts: &Vec<usize>, memo: &mut Vec<Vec<i64>>) -> i64 {
    let n = cnts.len() - 1;
    if cnt == 75 {
        return 1;
    }
    if depth == n + 1 || cnt > 75 {
        return 0;
    }
    if memo[cnt][depth] != -1 {
        return memo[cnt][depth];
    }
    let mut ret = 0;
    for i in 0..(cnts[depth] + 1) {
        let ncnt = cnt * (i + 1);
        ret += calc(depth + 1, ncnt, cnts, memo);
    }
    memo[cnt][depth] = ret;
    return ret;
}

fn main() {
    let n = read::<usize>();
    let mut cnts = vec![0; n + 1];
    for i in 1..(n + 1) {
        let mut v = i;
        for j in 2..(i + 1) {
            while v % j == 0 {
                cnts[j] += 1;
                v /= j;
            }
        }
    }
    let mut memo = vec![vec![-1; n + 1]; 100];
    let ans = calc(0, 1, &cnts, &mut memo);
    println!("{}", ans);
}