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)

#![allow(
    non_snake_case,
    unused_variables,
    unused_assignments,
    unused_mut,
    dead_code
)]
//use permutohedron::LexicalPermutation as _;
use proconio::input;
//use proconio::marker::Chars;
//use proconio::marker::Usize1;
//use std::collections::HashSet;
//use std::collections::HashMap;
//use std::collections::BTreeMap;
//use std::cmp::*;
// use std::num;
const MOD: i64 = 1_000_000_007;
fn main() {
    input! {
        n:usize,m:usize
    }
    let mut fact = vec![1i64; m + 1];
    for i in 2..(1 + m) {
        fact[i] = fact[i - 1] * (i as i64) % MOD;
    }
    let perm = |m, n| fact[m] * modInv(fact[m - n]) % MOD;
    let comb = |m, n| fact[m] * modInv(fact[m - n]) % MOD * modInv(fact[n]) % MOD;
    //let comb2 = |m| n * (n - 1) * modInv(2) % MOD;
    // Aを固定して、Bを考える。
    // 求めたいパターンは、全てのパターン(0個以上が同じ) - 1個以上が同じ + 2個以上が同じ - ...
    // all = m P n
    // k以上が同じケース。
    let mut ans = 0;
    for i in 0..n + 1 {
        if i % 2 == 0 {
            ans += comb(n, i) * perm(m - i, n - i) % MOD;
        } else {
            ans -= comb(n, i) * perm(m - i, n - i) % MOD;
        };
    }
    ans = ans % MOD * perm(m, n) % MOD;
    // println!("{},{}", fact[2], modInv(fact[2]));
    // println!("{}", x);
    println!("{}", (ans + MOD) % MOD);
}

fn modPow(a: i64, n: i64) -> i64 {
    let mut res = 1;
    let mut a = a;
    let mut n = n;
    while n > 0 {
        if n % 2 != 0 {
            res = res * a % MOD;
        }
        a = a * a % MOD;
        n = n / 2;
    }
    return res;
}
fn modInv(a: i64) -> i64 {
    modPow(a, MOD - 2)
}