Problem:
Score : 500 points

Problem Statement

Count the pairs of length-N sequences consisting of integers between 1 and M (inclusive), A_1, A_2, \cdots, A_{N} and B_1, B_2, \cdots, B_{N}, that satisfy all of the following conditions:

A_i \neq B_i, for every i such that 1\leq i\leq N.

A_i \neq A_j and B_i \neq B_j, for every (i, j) such that 1\leq i < j\leq N.

Since the count can be enormous, print it modulo (10^9+7).

Constraints

1\leq N \leq M \leq 5\times10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M

Output

Print the count modulo (10^9+7).

Sample Input 1

2 2

Sample Output 1

2

A_1=1,A_2=2,B_1=2,B_2=1 and A_1=2,A_2=1,B_1=1,B_2=2 satisfy the conditions.

Sample Input 2

2 3

Sample Output 2

18

Sample Input 3

141421 356237

Sample Output 3

881613484

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

const M: u64 = 1000_000_007;

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

    let c = Combination::new(m);
    let mut sign = false;
    let mut r = 0;
    for i in 0..=n {
        let k = c.comb(n, i) * c.perm(m - i, n - i) % M;
        if sign {
            if k > r {
                r += M;
            }
            r -= k;
        } else {
            r += k;
            if r > M {
                r -= M;
            }
        }
        sign ^= true;
    }

    println!("{}", r * c.perm(m, n) % M);
}

struct Combination {
    fact: Vec<u64>,
    inv_fact: Vec<u64>,
}

impl Combination {
    fn new(n: usize) -> Combination {
        let mut fact = vec![1; n + 1];
        for i in 1..=n {
            fact[i] = fact[i - 1] * i as u64 % M;
        }
        let mut inv_fact = vec![1; n + 1];
        inv_fact[n] = pow(fact[n], M - 2);
        for i in (1..=n).rev() {
            inv_fact[i - 1] = inv_fact[i] * i as u64 % M;
        }

        Combination {fact, inv_fact}
    }

    fn perm(&self, n: usize, r: usize) -> u64 {
        self.fact[n] * self.inv_fact[n - r] % M
    }
    
    fn comb(&self, n: usize, r: usize) -> u64 {
        self.perm(n, r) * self.inv_fact[r] % M
    }
}

fn pow(mut a: u64, mut n: u64) -> u64 {
    let mut r = 1;
    while n > 0 {
        if n & 1 > 0 {
            r = r * a % M;
        }
        a = a * a % M;
        n >>= 1;
    }
    r
}