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 std::io::{self, BufRead};

const M: i64 = 1000000007;

fn pow(p: i64, n: i64) -> i64 {
  let mut q = n;
  let mut m = p;
  let mut ans = 1;
  while q > 0 {
    if q % 2 == 1 {
      ans = (ans * m) % M;
    }
    q /= 2;
    m = (m * m) % M;
  }
  ans
}

fn main() {
  let stdin = io::stdin();
  let mut lines = stdin.lock().lines();
  let line = lines.next().unwrap().unwrap();
  let vs: Vec<usize> = line.split(' ').map(|x| x.parse().unwrap()).collect();
  let n = vs[0];
  let k = vs[1];

  let mut counts: Vec<i64> = vec![0; k];
  for i in 0..k {
    let x = k - i;
    let mut total = pow((k / x) as i64, n as i64);
    let mut xx = 2 * x;
    while xx <= k {
      total = (total - counts[xx as usize - 1]) % M;
      xx += x;
    }
    counts[x as usize - 1] = total
  }

  let ans = counts.iter().enumerate().map(|(i, c)| *c * (i as i64 + 1) % M).fold(0, |acc, x| (acc + x) % M);
  println!("{}", ans);
}