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)

use num::One;
use proconio::input;
use std::{
    fmt::{self, Display},
    iter::Sum,
    ops::{Add, Mul, Sub},
};

fn main() {
    input! {
        n: usize,
        k: usize,
    }

    let mut counts = vec![Zp::unchecked(0); k + 1];

    for x in (1..=k).rev() {
        counts[x] = num::pow(Zp::unchecked(k / x), n)
            - (2..)
                .take_while(|m| m * x <= k)
                .map(|m| counts[m * x])
                .sum::<Zp>();
    }

    let ans = counts
        .into_iter()
        .enumerate()
        .map(|(m, c)| Zp::new(m) * c)
        .sum::<Zp>();
    println!("{}", ans);
}

const P: usize = 1_000_000_007;

#[derive(Debug, Clone, Copy)]
struct Zp {
    repr: usize,
}

impl Zp {
    fn new(val: usize) -> Self {
        Self { repr: val % P }
    }

    fn unchecked(repr: usize) -> Self {
        Self { repr }
    }
}

impl Display for Zp {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(&self.repr, fmt)
    }
}

impl Add for Zp {
    type Output = Self;

    fn add(self, rhs: Self) -> Self {
        Self::new(self.repr + rhs.repr)
    }
}

impl Sub for Zp {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self {
        Self::new(P + self.repr - rhs.repr)
    }
}

impl Mul for Zp {
    type Output = Self;

    fn mul(self, rhs: Self) -> Self {
        Self::new(self.repr * rhs.repr)
    }
}

impl Sum for Zp {
    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(Self::unchecked(0), Add::add)
    }
}

impl One for Zp {
    fn one() -> Self {
        Zp::unchecked(1)
    }
}