output_description: Print the count modulo (10^9+7).
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
attempt: import sys
  
  
  def input():
      return sys.stdin.readline().strip()
  
  
  def list2d(a, b, c):
      return [[c] * b for i in range(a)]
  
  
  def list3d(a, b, c, d):
      return [[[d] * c for j in range(b)] for i in range(a)]
  
  
  def list4d(a, b, c, d, e):
      return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
  
  
  def ceil(x, y=1):
      return int(-(-x // y))
  
  
  def INT():
      return int(input())
  
  
  def MAP():
      return map(int, input().split())
  
  
  def LIST(N=None):
      return list(MAP()) if N is None else [INT() for i in range(N)]
  
  
  def Yes():
      print("Yes")
  
  
  def No():
      print("No")
  
  
  def YES():
      print("YES")
  
  
  def NO():
      print("NO")
  
  
  sys.setrecursionlimit(10**9)
  INF = 10**19
  MOD = 10**9 + 7
  EPS = 10**-10
  
  
  class ModTools:
      """階乗・逆元用のテーブルを構築する"""
  
      def __init__(self, MAX, MOD):
  
          # nCrならn、nHrならn+rまで作る
          MAX += 1
          self.MAX = MAX
          self.MOD = MOD
          # 階乗テーブル
          factorial = [1] * MAX
          factorial[0] = factorial[1] = 1
          for i in range(2, MAX):
              factorial[i] = factorial[i - 1] * i % MOD
          # 階乗の逆元テーブル
          inverse = [1] * MAX
          # powに第三引数入れると冪乗のmod付計算を高速にやってくれる
          inverse[MAX - 1] = pow(factorial[MAX - 1], MOD - 2, MOD)
          for i in range(MAX - 2, -1, -1):
              # 最後から戻っていくこのループならMAX回powするより処理が速い
              inverse[i] = inverse[i + 1] * (i + 1) % MOD
          self.fact = factorial
          self.inv = inverse
  
      def nCr(self, n, r):
          """組み合わせ"""
  
          if n < r:
              return 0
          # 10C7 = 10C3
          r = min(r, n - r)
          # 分子の計算
          numerator = self.fact[n]
          # 分母の計算
          denominator = self.inv[r] * self.inv[n - r] % self.MOD
          return numerator * denominator % self.MOD
  
      def nHr(self, n, r):
          """重複組み合わせ"""
  
          # r個選ぶところにN-1個の仕切りを入れる
          return self.nCr(r + n - 1, r)
  
      def nPr(self, n, r):
          """順列"""
  
          if n < r:
              return 0
          return self.fact[n] * self.inv[n - r] % self.MOD
  
  
  N, M = MAP()
  
  mt = ModTools(M + 1, MOD)
  acnt = mt.nPr(M, N)
  
  bcnt = 0
  for i in range(N + 1):
      bcnt += mt.nCr(N, i) * mt.nPr(M - i, N - i) * (-1) ** i
      bcnt %= MOD
  ans = acnt * bcnt % MOD
  print(ans)
  
problem_description: 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).
samples: [{"input": "2 2", "output": "2\n    \n\nA_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.\n\n* * *"}, {"input": "2 3", "output": "18\n    \n\n* * *"}, {"input": "141421 356237", "output": "881613484"}]