#include <bits/stdc++.h>
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (begin); i > (end); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())

#define pb push_back
#define f first
#define s second
#define ll long long
using namespace std;

using vec = vector<ll>;
using mat = vector<vec>;
using Pii = pair<ll, ll>;
using PiP = pair<ll, Pii>;
using PPi = pair<Pii, ll>;

constexpr ll MOD = 1000000007;

template <int mod> struct ModInt {
  // using ll = long long;
  static int get_mod() { return mod; }
  static int get_primitive_root() {
    static int primitive_root = 0;
    if (!primitive_root) {
      primitive_root = [&]() {
        std::set<int> fac;
        int v = mod - 1;
        for (ll i = 2; i * i <= v; i++)
          while (v % i == 0)
            fac.insert(i), v /= i;
        if (v > 1)
          fac.insert(v);
        for (int g = 1; g < mod; g++) {
          bool ok = true;
          for (auto i : fac)
            if (ModInt(g).power((mod - 1) / i) == 1) {
              ok = false;
              break;
            }
          if (ok)
            return g;
        }
        return -1;
      }();
    }
    return primitive_root;
  }
  int val;
  constexpr ModInt() : val(0) {}
  constexpr ModInt &_setval(ll v) {
    val = (v >= mod ? v - mod : v);
    return *this;
  }
  constexpr ModInt(ll v) { _setval(v % mod + mod); }
  explicit operator bool() const { return val != 0; }
  constexpr ModInt operator+(const ModInt &x) const {
    return ModInt()._setval((ll)val + x.val);
  }
  constexpr ModInt operator-(const ModInt &x) const {
    return ModInt()._setval((ll)val - x.val + mod);
  }
  constexpr ModInt operator*(const ModInt &x) const {
    return ModInt()._setval((ll)val * x.val % mod);
  }
  constexpr ModInt operator/(const ModInt &x) const {
    return ModInt()._setval((ll)val * x.inv() % mod);
  }
  constexpr ModInt operator-() const { return ModInt()._setval(mod - val); }
  constexpr ModInt &operator+=(const ModInt &x) { return *this = *this + x; }
  constexpr ModInt &operator-=(const ModInt &x) { return *this = *this - x; }
  constexpr ModInt &operator*=(const ModInt &x) { return *this = *this * x; }
  constexpr ModInt &operator/=(const ModInt &x) { return *this = *this / x; }
  friend constexpr ModInt operator+(ll a, const ModInt &x) {
    return ModInt()._setval(a % mod + x.val);
  }
  friend constexpr ModInt operator-(ll a, const ModInt &x) {
    return ModInt()._setval(a % mod - x.val + mod);
  }
  friend constexpr ModInt operator*(ll a, const ModInt &x) {
    return ModInt()._setval(a % mod * x.val % mod);
  }
  friend constexpr ModInt operator/(ll a, const ModInt &x) {
    return ModInt()._setval(a % mod * x.inv() % mod);
  }
  constexpr bool operator==(const ModInt &x) const { return val == x.val; }
  constexpr bool operator!=(const ModInt &x) const { return val != x.val; }
  bool operator<(const ModInt &x) const {
    return val < x.val;
  } // To use std::map<ModInt, T>
  friend std::istream &operator>>(std::istream &is, ModInt &x) {
    ll t;
    is >> t;
    x = ModInt(t);
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &x) {
    os << x.val;
    return os;
  }
  constexpr ll power(ll n) const {
    ll ans = 1, tmp = this->val;
    while (n) {
      if (n & 1)
        ans = ans * tmp % mod;
      tmp = tmp * tmp % mod;
      n /= 2;
    }
    return ans;
  }
  constexpr ll inv() const { return this->power(mod - 2); }
  constexpr ModInt operator^(ll n) const { return ModInt(this->power(n)); }
  constexpr ModInt &operator^=(ll n) { return *this = *this ^ n; }

  inline ModInt fac() const {
    static std::vector<ModInt> facs;
    int l0 = facs.size();
    if (l0 > this->val)
      return facs[this->val];

    facs.resize(this->val + 1);
    for (int i = l0; i <= this->val; i++)
      facs[i] = (i == 0 ? ModInt(1) : facs[i - 1] * ModInt(i));
    return facs[this->val];
  }

  ModInt doublefac() const {
    ll k = (this->val + 1) / 2;
    if (this->val & 1)
      return ModInt(k * 2).fac() / ModInt(2).power(k) / ModInt(k).fac();
    else
      return ModInt(k).fac() * ModInt(2).power(k);
  }

  ModInt nCr(const ModInt &r) const {
    if (this->val < r.val)
      return ModInt(0);
    return this->fac() / ((*this - r).fac() * r.fac());
  }

  ModInt sqrt() const {
    if (val == 0)
      return 0;
    if (mod == 2)
      return val;
    if (power((mod - 1) / 2) != 1)
      return 0;
    ModInt b = 1;
    while (b.power((mod - 1) / 2) == 1)
      b += 1;
    int e = 0, m = mod - 1;
    while (m % 2 == 0)
      m >>= 1, e++;
    ModInt x = power((m - 1) / 2), y = (*this) * x * x;
    x *= (*this);
    ModInt z = b.power(m);
    while (y != 1) {
      int j = 0;
      ModInt t = y;
      while (t != 1)
        j++, t *= t;
      z = z.power(1LL << (e - j - 1));
      x *= z, z *= z, y *= z;
      e = j;
    }
    return ModInt(std::min(x.val, mod - x.val));
  }
};

using mint = ModInt<MOD>;

int main() {
  mint N, M;
  cin >> N >> M;
  if (N.val < M.val) {
    swap(N, M);
  }
  mint ans = 0;
  if ((N - M).val > 1) {
    cout << 0 << endl;
    return 0;
  } else if (N == M) {

    ans = 2 * N.fac() * N.fac();
  } else {
    ans = N.fac() * M.fac();
  }

  cout << ans << endl;
  return 0;
}

Measured memory_bytes: 1024