#include <bits/stdc++.h>
using namespace std;
template <class T>
using VV = vector<vector<T>>;
template <class T>
inline T SMIN(T& a, const T b) {
  return a = (a > b) ? b : a;
}
template <class T>
inline T SMAX(T& a, const T b) {
  return a = (a < b) ? b : a;
}
template <class Iter>
void __kumaerrc(Iter begin, Iter end) {
  for (; begin != end; ++begin) {
    cerr << *begin << ',';
  }
  cerr << endl;
}
void __kumaerr(istream_iterator<string> it) {
  (void)it;
  cerr << endl;
}
template <typename T, typename... Args>
void __kumaerr(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << "=" << a << ", ", __kumaerr(++it, args...);
}
template <typename S, typename T>
std::ostream& operator<<(std::ostream& _os, const std::pair<S, T>& _p) {
  return _os << "{" << _p.first << ',' << _p.second << "}";
}
const int MOD = 1000000007;
struct ModInt {
  unsigned int val;
  ModInt() : val(0) {}
  ModInt(int v) { norm(v % MOD); }
  ModInt(long long v) { norm(v % MOD); }
  ModInt& norm(long long v) {
    v = v < 0 ? v % MOD + MOD : v;
    v = v >= MOD ? v - MOD : v;
    val = (unsigned int)v;
    return *this;
  }
  explicit operator bool() const { return val != 0; }
  ModInt operator-() const { return ModInt(0) - *this; }
  ModInt& operator+=(ModInt that) { return norm((long long)val + that.val); }
  ModInt& operator-=(ModInt that) { return norm((long long)val - that.val); }
  ModInt& operator*=(ModInt that) {
    val = (unsigned long long)val * that.val % MOD;
    return *this;
  }
  ModInt& operator/=(ModInt that) { return *this *= that.inv(); }
  ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
  ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
  ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
  ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
  ModInt pow(long long n) const {
    ModInt x = *this, res = 1;
    while (n > 0) {
      if (n & 1) res *= x;
      x *= x, n >>= 1;
    }
    return res;
  }
  ModInt inv() const { return (*this).pow(MOD - 2); }
  bool operator==(ModInt that) const { return val == that.val; }
  bool operator!=(ModInt that) const { return val != that.val; }
  friend ostream& operator<<(ostream& os, const ModInt& that) {
    return os << that.val;
  }
};
long long choose(long long n, long long k) {
  if (n < k) return 0;
  const int MAX_N = 1e6 + 1;
  assert(k <= MAX_N);
  static long long fact[MAX_N + 1], revfact[MAX_N + 1], rev[MAX_N + 1];
  if (rev[1] == 0) {
    rev[1] = 1;
    for (int i = 2; i <= MAX_N; i++)
      rev[i] = rev[MOD % i] * (MOD - MOD / i) % MOD;
    fact[0] = 1, revfact[0] = 1;
    for (int i = 1; i <= MAX_N; i++) {
      fact[i] = fact[i - 1] * i % MOD;
      revfact[i] = revfact[i - 1] * rev[i] % MOD;
    }
  }
  return fact[n] * revfact[n - k] % MOD * revfact[k] % MOD;
}
const int MAX_N = 1e6 + 1;
int N, M, A, B;
ModInt powM[MAX_N], powN[MAX_N], fact[MAX_N];
ModInt f(long long x) {
  ModInt res = fact[x];
  res *= ModInt(choose(N - 2, x));
  res *= ModInt(choose(M - 1, x));
  res *= powM[N - 2 - x];
  assert(N - x - 3 >= -1);
  if (N - x - 3 >= 0) res *= ModInt(x + 2) * powN[N - x - 3];
  return res;
}
void solve() {
  powM[0] = powN[0] = fact[0] = ModInt(1);
  for (int i = 0; i < (MAX_N - 1); ++i) {
    powM[i + 1] = powM[i] * ModInt(M);
    powN[i + 1] = powN[i] * ModInt(N);
    fact[i + 1] = fact[i] * (i + 1);
  }
  ModInt res;
  for (int x = 0; x <= (min(M - 1, N - 2)); ++x) res += f(x);
  cout << res << endl;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout << setprecision(12) << fixed;
  cin >> N >> M >> A >> B;
  solve();
  return 0;
}
