Problem:
Score : 500 points

Problem Statement

Consider sequences \{A_1,...,A_N\} of length N consisting of integers between 1 and K (inclusive).

There are K^N such sequences. Find the sum of \gcd(A_1, ..., A_N) over all of them.

Since this sum can be enormous, print the value modulo (10^9+7).

Here \gcd(A_1, ..., A_N) denotes the greatest common divisor of A_1, ..., A_N.

Constraints

2 \leq N \leq 10^5

1 \leq K \leq 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the sum of \gcd(A_1, ..., A_N) over all K^N sequences, modulo (10^9+7).

Sample Input 1

3 2

Sample Output 1

9

\gcd(1,1,1)+\gcd(1,1,2)+\gcd(1,2,1)+\gcd(1,2,2)
+\gcd(2,1,1)+\gcd(2,1,2)+\gcd(2,2,1)+\gcd(2,2,2)
=1+1+1+1+1+1+1+2=9

Thus, the answer is 9.

Sample Input 2

3 200

Sample Output 2

10813692

Sample Input 3

100000 100000

Sample Output 3

742202979

Be sure to print the sum modulo (10^9+7).

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

macro_rules! bind_from_vec {
    ( $($variable:ident),+ = $vector:expr ) => {
        let mut v = $vector.clone().into_iter();
        $(let $variable = v.next().unwrap();)+
    };
}

macro_rules! read_line {
    () => {{
        let mut input = String::new();
        std::io::stdin().read_line(&mut input).unwrap();
        input
    }};
}

pub fn read_to_vec<T: std::str::FromStr>() -> Vec<T> {
    read_line!().split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn pow_mod(base: usize, exp: usize, modulo: usize) -> usize {
    (0..std::mem::size_of::<usize>() * 8).rev()
        .fold(1, |acc, i|
            (acc.pow(2).rem_euclid(modulo) * base.pow((exp >> i & 1) as u32)).rem_euclid(modulo)
        )
}

fn main() {
    const MOD: usize = 1_000_000_000 + 7;

    bind_from_vec!(n, k = read_to_vec());

    let mut mem = Vec::with_capacity(k);
    mem.resize(k, 0);

    for x in (1..=k).rev() {
        mem[x - 1] = pow_mod(k/x, n, MOD);
        for i in 2..=k/x {
            mem[x - 1] = (MOD + mem[x - 1] - mem[(i * x) - 1] % MOD) % MOD;
            mem[x - 1] %= MOD;
        }
    }

    let mut ans = 0;

    for i in 1..=k {
        ans += i * mem[i - 1] % MOD;
        ans %= MOD;
    }

    println!("{}", ans);
}