Snuke has N dogs and M monkeys. He wants them to line up in a row.
As a Japanese saying goes, these dogs and monkeys are on bad terms. ("ken'en no naka", literally "the relationship of dogs and monkeys", means a relationship of mutual hatred.) Snuke is trying to reconsile them, by arranging the animals so that there are neither two adjacent dogs nor two adjacent monkeys.
How many such arrangements there are? Find the count modulo 10^9+7 (since animals cannot understand numbers larger than that).
Here, dogs and monkeys are both distinguishable. Also, two arrangements that result from reversing each other are distinguished.

-----Constraints-----
 - 1 ≤ N,M ≤ 10^5

-----Input-----
Input is given from Standard Input in the following format:
N M

-----Output-----
Print the number of possible arrangements, modulo 10^9+7.

-----Sample Input-----
2 2

-----Sample Output-----
8

We will denote the dogs by A and B, and the monkeys by C and D. There are eight possible arrangements: ACBD, ADBC, BCAD, BDAC, CADB, CBDA, DACB and DBCA.

Difficulty: introductory

Starter code:

Solutions:
import math
n, m = map(int, input().split())
mod = 10**9+7
if abs(n-m) > 1:
    print(0)
    return

dog = math.factorial(n)
monkey = math.factorial(m)
if abs(n-m) == 1:
    ans = dog*monkey % mod
elif n == m:
    ans = dog*monkey*2 % mod
print(ans%mod)

N,M = map(int,input().split())
a = [0]*(max(N,M)+1)
a[0] = 1
a[1] = 1
for i in range(2,len(a)):
    a[i] = i * a[i-1] % 1000000007
    
if N==M:
    print(a[N]*a[M]*2 % 1000000007)
elif abs(N-M)==1:
    print(a[N]*a[M] % 1000000007)
else:
    print(0)

N, M = map(int, input().split())

x = abs(N-M)
if x >= 2:
    print(0)
else:
    mod = 10**9+7
    a = 1
    for i in range(2, N+1):
        a *= i
        a %= mod
    b = 1
    for i in range(2, M+1):
        b *= i
        b %= mod
    
    if x == 0:
        print(a*b*2%mod)
    else:
        print(a*b%mod)

N, M = list(map(int, input().split()))
mod = 1000000007

if abs(N - M) > 1:
    print((0))
elif (N + M) % 2 == 1:
    x = max(N, M)
    y = min(N, M)
    Sum = 1
    for i in range(N + M):
        if i % 2 == 0:
            Sum *= x - (i // 2)
            Sum %= mod
        else:
            Sum *= y - (i // 2)
            Sum %= mod
    print(Sum)
else:
    Sum = 1
    for i in range(2 * N):
        Sum *= N - (i // 2)
        Sum %= mod
    Sum *= 2
    Sum %= mod
    print(Sum)


import math
n,m=map(int,input().split());r=10**9+7
if n==m: print(2*math.factorial(n)*math.factorial(m)%r)
elif abs(n-m)==1: print(math.factorial(n)*math.factorial(m)%r)
else: print(0)

n, m = list(map(int, input().split()))

mod = 10**9 + 7
l = n+m
ans = 1
b = max(n, m)
s = min(n, m)
for i in range(l):
    if i % 2 == 0:
        tmp = b-i//2
        if tmp > 0:
            ans = (ans % mod) * (tmp % mod)
        else:
            print((0))
            return
    else:
        tmp = s-i//2
        if tmp > 0:
            ans = (ans % mod) * (tmp % mod)
        else:
            print((0))
            return
if l%2 == 0:    
    ans = (ans % mod) * (2 % mod)
print((ans%mod))


n, m = list(map(int, input().split()))

def f(n):
    ans = n
    for i in range(1, n):
        ans *= i
        ans %= 1000000007
    return ans

if n == m:
    print(((f(n))**2 *2)%1000000007)
elif n == m+1 or m == n+1:
    print((f(n)*f(m))%1000000007)
else:
    print(0)

from math import factorial

n, m = map(int, input().split())
if n == m:
    print((factorial(n) ** 2 * 2) % (10 ** 9 + 7))
elif abs(n - m) == 1:
    print((factorial(n) * factorial(m)) % (10 ** 9 + 7))
else:
    print(0)

n,m = map(int, input().split(" "))
if abs(n-m) >= 2:
  print(0)
else:
  temp = 1
  mod = 10 ** 9 + 7
  for i in range(1, min(n,m)+1):
    temp *= i
    temp %= mod
  #print(temp)
  if n != m:
    print((temp**2*(max(n,m)) % mod))
  else:
    print((temp**2*2 % mod))

import math
n, m = map(int, input().split())
mod = 10 ** 9 + 7

if n == m:
  res = 2 * math.factorial(n) * math.factorial(m)
  print(res % mod)
elif abs(n - m) == 1:
  res = math.factorial(n) * math.factorial(m)
  print(res % mod)  
else:
  print(0)

n,m = list(map(int,input().split()))

p = 10**9+7
def ka(t):
    an = 1
    for i in range(2,t+1):
        an = (an*i)%p
    return an

if n==m+1 or n==m-1:
    print(((ka(n)*ka(m))%p))
elif n==m:
    print(((ka(n)*ka(m)*2)%p))
else:
    print((0))


n, m = [int(x) for x in input().split()]
mod = 10 ** 9 + 7

def kaizyou(p):
  ans = 1
  for i in range(1,p+1):
    ans *= i
    if ans >= mod:
      ans %= mod
  return ans
  
res = 0
if abs(m - n) <= 1:
  res += kaizyou(m)
  res %= mod
  res *= kaizyou(n)
  res %= mod
  if n == m:
    res *= 2
  res %= mod

print(res)

# -*- coding: utf-8 -*-
"""
Created on Sun Sep 27 02:58:21 2020

@author: liang
"""

N, M = list(map(int,input().split()))
MOD = 10**9 + 7

if abs(N-M) >= 2:
    ans = 0
else:
    ans = 1
    for i in range(1,N+1):
        ans *= i
        ans %= MOD

    for i in range(1,M+1):
        ans *= i
        ans %= MOD
    
    if N == M:
        ans *= 2
        ans %= MOD
print(ans)


#/usr/bin/env python

n, m = list(map(int, input().split()))
MOD = int(1e9)+7
fac = [-1 for _ in range(100001)]
fac[1] = 1 

for i in range(1, 100000):
    fac[i+1] = ((i+1)*fac[i])%MOD

if abs(n-m) > 1:
    print((0))
    return

ans = 0 
if n == m:
    ans = (fac[n]*fac[m]*2)%MOD
else:
    ans = (fac[n]*fac[m])%MOD

print(ans)


import sys
input = sys.stdin.readline

#l = list(map(int, input().split()))
#import numpy as np
#arr = np.array([int(i) for i in input().split()])
'''
a,b=[],[]
for i in range():
    A, B = map(int, input().split())
    a.append(A)   
    b.append(B)'''

n,m=map(int,input().split())
if abs(n-m)>1:
    print(0)
    return

f=[1]
for i in range(1,max(n,m)+1):
    x=f[i-1]*i
    if x>10**9+7:
        x%=10**9+7
    f.append(x)
if n!=m:
    print(f[n]*f[m]%(10**9+7))
else:
    print(f[n]*f[m]*2%(10**9+7))

N, M = [int(x) for x in input().split()]
MOD = 10**9+7

if max(N, M) - min(N, M) > 1:
    print((0))
    return


def floor(n):
    result = n
    for i in range(n-1, 0, -1):
        result *= i
        result %= MOD

    return result


r = floor(max(N, M))
t = floor(min(N, M))

if r == t:
    result = (r * t * 2) % MOD
else:
    result = (r * t) % MOD

print(result)


import math
n,m = map(int,input().split())
mod = 10**9+7
fact_n = math.factorial(n) % mod
fact_m = math.factorial(m) % mod

if abs(n-m) >= 2:
  print(0)
elif n == m:
  print((fact_n * fact_m * 2) % mod)
else:
  print((fact_n * fact_m) % mod)

import math
def ModFact(N,Mod):
    Num = 1
    for T in range(2,N+1):
        Num = (Num*T)%Mod
    return Num
  
N,M = (int(T) for T in input().split())
Mod = 10**9+7
if N==M:
    print((2*ModFact(N,Mod)*ModFact(M,Mod))%Mod)
elif N==M+1 or M==N+1:
    print((ModFact(N,Mod)*ModFact(M,Mod))%Mod)
else:
    print(0)

from math import factorial as fac

N,M = map(int,input().split())

if abs(N-M) > 1:
  print(0)
elif abs(N-M) == 1:
  print((fac(N)*fac(M))%1000000007)
else:
  print((2*fac(N)*fac(M))%1000000007)

n, m  =list(map(int, input().split()))

mod = 10**9+7
ans = 1


if abs(n-m) >= 2:
    ans = 0
elif abs(n-m) == 1:
    for i in range(1, max(n, m)+1):
        ans *= i
        ans %= mod
    for j in range(1, min(n, m)+1):
        ans *= j
        ans %= mod
elif abs(n-m) == 0:
    for i in range(1, n+1):
        ans *= i
        ans %= mod
    ans **= 2
    ans*= 2
    ans %= mod


print(ans)


n,m=list(map(int,input().split()))
if abs(n-m)>1:
  print((0))
  return

sm=1 if n!=m else 2
while n>0:
  sm=(sm*n)%(10**9+7)
  n-=1
while m>0:
  sm=(sm*m)%(10**9+7)
  m-=1
print(sm)


from math import factorial
N,M=map(int,input().split())
ans=0
if abs(N-M)>1:
    ans=0
else:
    if N==M:
        a=N
        b=M
        ans=factorial(a)*factorial(b)*2
    else:
        a=max(N,M)
        b=min(N,M)
        ans=factorial(a)*factorial(b)
print(ans%(10**9+7))

def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs

MOD = 10**9+7
fact, fact_inv = prepare(2*10**5, MOD)

n, m = map(int,input().split())
if abs(n-m) > 1:
    print(0)
elif abs(n-m) == 1:
    print(fact[n] * fact[m] % MOD)
else:
    print(2 * fact[n] % MOD * fact[m] % MOD)

import math

n, m = map(int, input().split())

if abs(n - m) >= 2:
    print(0)

elif abs(n - m) == 1:
    ans = math.factorial(n) * math.factorial(m)
    ans %= 10 ** 9 + 7
    print(ans)

else:
    ans = 2*math.factorial(n) * math.factorial(m)
    ans %= 10 ** 9 + 7
    print(ans)

import math
n,m = map(int,input().split())
mod = 10**9+7
fact_n = math.factorial(n) % mod
fact_m = math.factorial(m) % mod

if abs(n-m) >= 2:
  print(0)
  return
elif n == m:
  print((fact_n * fact_m * 2) % mod)
else:
  print((fact_n * fact_m) % mod)

with open(0) as f:
    N, M = map(int, f.read().split())
mod = 1000000007

def factorial(n):
    res = 1
    for i in range(1,n+1):
        res = res * i %mod
    return res

if abs(N-M) > 1:
    ans = 0
elif N == M:
    ans = 2*factorial(M)**2 %mod 
else:
    N, M = max(N, M), min(N, M)
    ans = N * factorial(M)**2 %mod
print(ans)

MOD = 1_000_000_007
n, m = map(int,input().split())
if abs(n-m)>1:
    print(0)
else:
    if abs(n-m)==1:
        ans = 1
    else:
        ans = 2
    for i in range(n):
        ans = (ans*(i+1))%MOD
    for i in range(m):
        ans = (ans*(i+1))%MOD
    print(ans)

import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
MOD = 10 ** 9 + 7
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def fact_mod(n, MOD):
    ret = 1
    for i in range(1, n + 1):
        ret *= i
        ret %= MOD
    return ret

def resolve():
    N, M = LI()

    if N == M:
        ans = 2 * pow(fact_mod(N, MOD), 2, MOD)
        ans %= MOD
        print(ans)
    elif abs(N - M) <= 1:
        ans = fact_mod(N, MOD) * fact_mod(M, MOD)
        ans %= MOD
        print(ans)
    else:
        print((0))


def __starting_point():
    resolve()

__starting_point()

import math
n,m=map(int,input().split())
N=math.factorial(n)
if abs(n-m)>1:
    print(0)
elif abs(n-m)==0:
    print(2*N*N%(10**9+7))
elif n>m:
    print((N*N//n)%(10**9+7))
else:
    print(N*N*m%(10**9+7))

n, m = map(int, input().split())

if abs(n-m) >= 2:
    print(0)
    return

ans = 1
div = 10**9+7

for i in range(1, n+1):
    ans = (ans * i) % div
for i in range(1, m+1):
    ans = (ans * i) % div

if n != m:
    print(ans)
else:
    print((ans*2)%div)

N,M=map(int,input().split())
mod = 10**9+7

factorial=[1 for i in range(10**5+5)]
for i in range(1,10**5+5):
    if i==1:factorial[i]=1
    else:factorial[i] = factorial[i-1]*i % mod
      
if abs(N-M)>1:
  print(0)
  return

if N==M:
  print(factorial[M]**2*2%mod)
else:
  print(factorial[M]*factorial[N]%mod)

mod = 10**9+7
n, m = map(int, input().split())
if abs(n-m) >= 2:
    print(0)
    return
x, y = 1, 1
for i in range(1, n+1):
    x *= i
    x %= mod
for i in range(1, m+1):
    y *= i
    y %= mod
if n == m:
    print((2*x*y)%mod)
else:
    print((x*y)%mod)

import math
n, m = map(int, input().split())
ans = 0
if n == m:
  ans = (math.factorial(n) * math.factorial(m)) * 2
elif  n + 1 == m or n == m + 1:
  ans = (math.factorial(n) * math.factorial(m))
else:
  ans = 0
ans = ans % (10 ** 9 + 7)
print(ans)

import sys
import math

mod = 10**9 + 7
N, M = map(int, sys.stdin.readline().split())
diff = abs(N - M)
if diff > 1:
    print(0)
    return

n_p = 1
for i in range(1, N+1):
    n_p *= i
    n_p %= mod
m_p = 1
for i in range(1, M+1):
    m_p *= i
    m_p %= mod

if diff == 0:
    print(2 * n_p * m_p % mod)
else:
    print(n_p * m_p % mod)

def main():
    N,M = list(map(int,input().split()))
    if abs(N-M) > 1:
        return 0
    N_mlt = 1
    M_mlt = 1
    for i in range(1,N+1,1):
        N_mlt *= i
        N_mlt = N_mlt%1000000007
        #print(i,N_mlt)
    for i in range(1,M+1,1):
        M_mlt *= i
        M_mlt = M_mlt%1000000007
        #print(i,M_mlt)
    #print(N_mlt,M_mlt)
    ans = (N_mlt*M_mlt)%1000000007
    if abs(N-M)==0:
        ans = (ans*2)%1000000007
        return  ans
    else:
        return ans

print((main()))


import math
a,b=map(int, input().split())

if abs(a-b) == 1:
    c = math.factorial(a)%(10**9+7)
    d = math.factorial(b)%(10**9+7)
    print(c*d%(10**9+7))
if abs(a-b) == 0:
    c = math.factorial(a)%(10**9+7)
    d = math.factorial(b)%(10**9+7)
    print(c*d*2%(10**9+7))
if abs(a-b) >= 2:
    print(0)

import math
N,M = map(int,input().split())
if abs(N-M) > 1:
    print(0)
    return

fac = 1
num = 10**9 + 7
for i in range(1,N+1):
    fac *= i
    if fac > num:
        fac %= num

fac2 = 1
for i in range(1,M+1):
    fac2 *= i
    if fac2 > num:
        fac2 %= num

if N == M:
    print(fac**2*2%num)
else:
    print(fac*fac2%num)

import math
mod = 10**9+7
ans = 1
n, m = map(int, input().split())
if abs(n - m) > 1:
  print(0)
  return
elif n == m:
  ans = 2
ans = ans * math.factorial(n) % mod
ans = ans * math.factorial(m) % mod
print(ans)

import math
n,m = map(int,input().split())

x = 10**9+7

ans = 0
if n == m:
    ans += math.factorial(n) * math.factorial(m) * 2
    print(ans % x)
    return
elif n >= m and n -m == 1:
    ans += math.factorial(n) * math.factorial(m)
    print(ans % x)
    return
elif m >= n and m -n== 1:
    ans += math.factorial(n) * math.factorial(m)
    print(ans % x)
    return
else:
    print(ans % x)

import math as m
N,M=map(int,input().split())
w=1000000007
if abs(N-M)<2:
    if N==M:
        print((m.factorial(N)**2*2)%w)
    else:
        print((m.factorial(N)*m.factorial(M))%w)
else:
    print(0)

N, M = list(map(int, input().split()))
mod = 10**9 + 7

def factorial(n):
    ans = 1
    i = 0
    while i < n:
        ans *= (n-i)
        ans %= mod
        i += 1
    return ans

if abs(N-M) >= 2:
    print((0))
elif N == M:
    ans = (factorial(N) * factorial(M) * 2) % mod
    print(ans)
else:
    ans = (factorial(N) * factorial(M)) % mod
    print(ans)


N,M=map(int,input().split())
abs_NM=abs(N-M)
if abs_NM>1:
    print(0)
    return

p=10**9+7
ans=1
for i in range(1,N+1):
    ans=(ans*i)%p
for i in range(1,M+1):
    ans=(ans*i)%p
if abs_NM==0:
    ans=(ans*2)%p

print(ans)

MOD =  pow(10,9)+7
def MODINV(n:int, MOD=MOD):
    return pow(n, MOD-2, MOD)

def perm(n, k, MOD):
    numer = 1
    for i in range(n, n-k, -1):
        numer *= i
        numer %= MOD
    return numer

def main():
    N, M = list(map(int, input().split()))
    if N == M+1 or N+1 == M:
        ans = (perm(N, N, MOD)*perm(M, M, MOD))%MOD
    elif N == M:
        ans = (2*(perm(N, N, MOD)*perm(M, M, MOD)))%MOD
    else:
        ans = 0
    print(ans)

def __starting_point():
    main()

__starting_point()

import math
n, m = list(map(int, input().split()))
if abs(n - m) >= 2:
    print((0))
elif n == m:
    print(((2 * math.factorial(n) * math.factorial(m)) % (10**9 + 7)))
else:
    print((math.factorial(n) * math.factorial(m) % (10**9 + 7)))


from math import factorial

mod = 10 ** 9 + 7
n, m = map(int, input().split())
print(
    ((factorial(n) % mod) ** 2 % mod) * 2 % mod
    if n == m
    else (factorial(n) % mod) * (factorial(m) % mod) % mod
    if abs(n - m) == 1
    else 0
)

from math import factorial as f
n, m = list(map(int, input().split()))
mod = 10 ** 9 + 7
if abs(n - m) == 1:
    res = f(n) * f(m)
    print((res % mod))
elif n == m:
    res = f(n) * f(m) * 2
    print((res % mod))
else:
    print((0))


def factorial(a):
    result = 1
    for i in range(1,a+1):
        result *= i
        result %= 1000000007
    return result
N, M = map(int, input().split())
if N == M:
    ans = 2*(factorial(N)**2) %1000000007
elif abs(N-M) == 1:
    ans = max(N,M)*(factorial(min(N,M))**2) %1000000007
else:
    ans =0
print(ans)

import math

N, M = map(int, input().split())

def mod(num):
    return num % (10 ** 9 + 7)

def calc():
    dp[1] = 1
    for i in range(2, maxmn + 1):
        dp[i] = mod(dp[i-1] * i)

absnm = abs(N - M)

maxmn = max(N, M)
dp = [0]*(maxmn + 1)

if absnm > 1:
    print(0)

else:
    calc()

    if absnm == 1:
        r = mod(dp[M] * dp[N])

    elif absnm == 0:
        r = mod(dp[M] * dp[N] * 2)

    else:
        r = 0

    print(r)

N,M =map(int,input().split())
a = abs(N-M)
mod = 10**9 + 7
n = 1
for i in range(N):
    n *= N-i
    n %= mod
m = 1
for i in range(M):
    m *= M-i
    m %= mod
if a > 1:
    print(0)
elif a == 1:
    print(n * m % mod)
else:
    print(n*m*2%mod)

import math


def main():
    N, M = list(map(int, input().split()))
    mod = 10 ** 9 + 7
    if abs(N - M) > 1:
        ans = 0
    elif N - M == 1:
        ans = (math.factorial(M)**2 * N) % mod
    elif N - M == -1:
        ans = (math.factorial(N)**2 * M) % mod
    else:
        ans = (math.factorial(N)**2 * 2) % mod

    print(ans)


def __starting_point():
    main()

__starting_point()

N, M = list(map(int, input().split()))
from math import factorial
mod = 10**9+7

if abs(N-M) > 1:
    print((0))
elif abs(N-M) == 1:
    print((factorial(N)*factorial(M)%mod))
else:
    print((2*factorial(N)*factorial(M)%mod))




import math
n,m = list(map(int,input().split()))
if abs(n-m)>1:
    print((0))
elif abs(n-m)==1:
    print(((math.factorial(n) * math.factorial(m))%(10**9+7)))
else:
    print(((2 * math.factorial(n) * math.factorial(m))%(10**9+7)))


n, m = list(map(int, input().split()))
mod = 10 ** 9 + 7


def permitation(x):
    res = 1
    for i in range(1, x + 1):
        res = res * i % mod
    return res


pn = permitation(n)
pm = permitation(m)

if n == m:
    res = pn * pm * 2 % mod
    print(res)
elif n == m - 1 or n == m + 1:
    res = pn * pm % mod
    print(res)
else:
    print((0))


N,M = map(int,input().rstrip().split(" "))
if abs(N - M) > 1:
    print(0)
else:
    ans = 1
    for i in range(1,N + 1):
        ans *= i
        ans %= 10 ** 9 + 7
    for i in range(1,M + 1):
        ans *= i
        ans %= 10 ** 9 + 7
    if N == M:
        ans *= 2
        ans %= 10 ** 9 + 7
    print(ans)

n, m = map(int, input().split())
n, m = max(n, m), min(n, m)
div = 10 ** 9 + 7
res = 1
if n - m == 0:
  for i in range(1, n + 1):
    res *= i
    res %= div
  res = res * res * 2
  print(res % div)
elif n - m == 1:
  for i in range(1, n + 1):
    res *= i
    res %= div
  for i in range(1, m + 1):
    res *= i
    res %= div
  print(res)
else:
  print(0)

n, m = map(int, input().split())

if n < m: # n >= m
    n, m = m, n

if m + 1 == n or m == n:
    # m! * 1 or 2 * n!
    if m + 1 == n:
        ans = 1
    else:
        ans = 2
    k = 1
    for i in range(1, n + 1):
        k *= i
        if i == m:
            ans *= k
        k = k % (10**9 + 7)
    ans *= k
    print(ans % (10**9 + 7))
else:
    print(0)

import math
n,m = map(int, input().split())
a = math.factorial(m)
b = math.factorial(n)
if 1 < abs(n-m):
    print(0)
elif abs(n-m) == 0:
    print((a*b*2)%1000000007)
elif abs(m-n) == 1:
    print((a*b)%1000000007)

n, m = list(map(int, input().split()))
if abs(n - m) > 1:
    print((0))
    return
ans = 1
for i in range(1, n + 1):
    ans *= i
    ans %= 10**9 + 7
for i in range(1, m + 1):
    ans *= i
    ans %= 10**9 + 7
if abs(n - m) == 0:
    ans *= 2
    ans %= 10**9 + 7
print(ans)


MOD=1000000007

def fac(x):
    ret=1
    for i in range(1,x+1):
        ret*=i
        ret%=MOD
    return ret

N,M=list(map(int,input().split()))

if N==M:
    print((fac(N)**2*2%MOD))
elif abs(N-M)==1:
    print((fac(N)*fac(M)%MOD))
else:
    print((0))


#79 C - Reconciled?
N,M = map(int,input().split())
MOD = 10**9 + 7

if abs(N-M) >= 2:
    ans = 0
else:
    # M! * N!
    Mfact = 1
    for m in range(1,M+1):
        Mfact = (Mfact * m)%MOD
    Nfact = 1
    for n in range(1,N+1):
        Nfact = (Nfact * n)%MOD
    ans = (Nfact*Mfact)%MOD
    if abs(N-M) == 0:
        ans = (ans * 2)%MOD
print(ans)

#!/usr/bin/env python3

# from numba import njit

# input = stdin.readline

MOD = 10**9 + 7

def modFact(x):
  if x < 1:
    raise ValueError
  res = 1
  for i in range(x):
    res = res * (i+1) % MOD
  return res

# @njit
def solve(n,m):
  if abs(n-m) > 1:
    return 0
  elif abs(n-m) == 1:
    return modFact(n) * modFact(m) % MOD
  else:
    return modFact(n) * modFact(m) * 2 % MOD


def main():
  N,M = list(map(int,input().split()))
  # a = list(map(int,input().split()))
  print((solve(N,M)))
  return

def __starting_point():
  main()

__starting_point()

import math
N, M = map(int, input().split())

mod = 10 ** 9 + 7

if abs(N - M) > 1:
  ans = 0
elif abs(N - M) == 1:
  ans = (math.factorial(N) % mod) * (math.factorial(M) % mod)
else:
  ans = (math.factorial(N) % mod) * (math.factorial(M) % mod) * 2
  
print(ans % mod)

def solve():
  N, M = map(int, input().split())
  if abs(N-M)>1:
    return 0
  mod = 10**9+7
  ans = 2-abs(N-M)
  for i in range(N):
    ans *= i+1
    ans %= mod
  for i in range(M):
    ans *= i+1
    ans %= mod
  return ans
print(solve())

n,m = list(map(int, input().split()))
if n > m:
    n,m = m,n
ans = 1
if m==n:

    while n > 0:
        ans *= n
        ans %= 10**9+7
        n -= 1
    ans = (2*(ans**2))%(10**9+7)
    print(ans)

elif m - n == 1:
    while n > 0:
        ans *= n
        ans %= 10**9+7
        n -= 1
    
    
    ans = (ans * (ans*m % (10**9+7))) % (10**9+7)
    print(ans)
else:
    print((0))


import math
N,M=map(int,input().split())
p=10**9 +7
dog=math.factorial(N)
mon=math.factorial(M)

if N==M:
  ans = ((dog*mon)*2) % p
elif abs(N-M) == 1:
  ans = (dog*mon) % p
else:
  ans=0
print(ans)

n, m = map(int, input().split())
mod = 10**9+7
"""
abs(n-m)>1の時、必ず隣り合ってしまうので0
n>mとしても一般性を失わない
if n<m: n, m = m, n
n==mnの時は、どちらを左端に置くか選べるので2倍
"""

if abs(n-m)>1: print(0)
else:
    if n<m: n, m = m, n
    n_parm = 1
    for i in range(n, 0, -1):
        n_parm = (n_parm*i)%mod
    m_parm = 1
    for i in range(m, 0, -1):
        m_parm = (m_parm*i)%mod
    ans = (n_parm * m_parm)%mod
    if m==n:
        ans = (ans*2)%mod
    print(ans)

N,M=map(int,input().split())
t=10**9+7
import math
n=math.factorial(N)%t
m=math.factorial(M)%t

if 2<=abs(N-M):
    print(0)
elif abs(N-M)==1:
    print((n*m)%t)
else:
    print((n*m*2)%t)

n, m = list(map(int, input().split()))

import math
if n == m:
    dog = math.factorial(n)
    mon = math.factorial(m)
    ans = dog * mon * 2
elif n == m + 1 or n == m - 1:
    dog = math.factorial(n)
    mon = math.factorial(m)
    ans = dog * mon
else:
    ans = 0

print((ans % (10 ** 9 + 7)))


n, m = list(map(int, input().split()))
mod = 10**9+7

def fact(n, mod):
    ans = 1
    for i in range(2, n + 1):
        ans = ans * i
        ans = ans % mod

    return ans


if abs(n - m) >= 2:
    print((0))
elif abs(n - m) == 1:
    print((fact(n,mod)*fact(m,mod) % mod))
elif abs(n - m) == 0:
    print((2 * fact(n, mod)*fact(m, mod) % mod))


n,m = list(map(int,input().split()))

ans = 0
rd = 10**9 + 7
if(abs(n-m) > 1):
    ans = 0
    print(ans)
elif(abs(n-m) == 1):
    tmp = min(n,m)
    tmp_mx = max(n,m)
    sm = 1
    for i in range(tmp):
        sm = (sm * (i+1))%rd
    
    ans = (sm * sm * tmp_mx)%rd
    print(ans)
else:
    sm = 1
    for i in range(n):
        sm = (sm * (i+1))%rd
    
    ans = (2*sm * sm)%rd
    print(ans)



N,M=list(map(int,input().split()))
if N==M+1:
    A=N
    B=M
    ans=1
elif N+1==M:
    A=M
    B=N
    ans=1
elif N==M:
    A=N
    B=M
    ans=2
else:
    print((0))
    return
ansa=1
ansb=1
for i in range(1,A+1):
    ansa=(ansa*i)%(10**9+7)
for j in range(1,B+1):
    ansb=(ansb*j)%(10**9+7)

print(((ansa*ansb*ans)%(10**9+7)))

    


def factorial(n, mod=10**9 + 7):
    a = 1
    for i in range(1, n + 1):
        a = a * i % mod
    return a


def main():
    N, M = list(map(int, input().split()))
    mod = 10 ** 9 + 7
    if abs(N - M) > 1:
        ans = 0
    elif abs(N - M) == 1:
        ans = (factorial(min(N, M))**2 * max(N, M)) % mod
    else:
        ans = (factorial(N)**2 * 2) % mod

    print(ans)


def __starting_point():
    main()

__starting_point()

n,m = map(int, input().split())

if abs(n-m) > 1:
  print(0)
  return

mod = 10**9+7
ans = 1
for i in range(1,n+1):
  ans *= i
  ans %= mod
for i in range(1,m+1):
  ans *= i
  ans %= mod
if (n+m)%2 == 0:
  ans *= 2
  ans %= mod
print(ans)

import sys

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inl = lambda: [int(x) for x in sys.stdin.readline().split()]
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

MOD = 10 ** 9 + 7


def fac(k):
    res = 1
    for i in range(2, k + 1):
        res = (res * i) % MOD
    return res


def solve():
    n, m = inl()
    if n < m:
        n, m = m, n
    if n - m > 1:
        return 0
    if n - m == 1:
        return fac(n) * fac(m) % MOD
    assert n == m
    a = fac(n)
    a = 2 * a * a % MOD
    return a


print(solve())


mod = 10 ** 9 + 7

def factorial(n, mod):
    fact = 1
    for integer in range(1, n + 1):
        fact *= integer
        fact %= mod
    return fact

N, M = map(int,input().split())
if abs(N - M) > 1:
    print(0)
else:
    ans = 1
    ans *= factorial(N, mod)
    ans *= factorial(M, mod)
    ans *= 2 - abs(N - M)
    ans %= mod
    print(ans)

N,M=map(int,input().split())
abs_NM=abs(N-M)
if abs_NM>1:
    print(0)
    return

p=10**9+7
min_=min(N,M)
max_=max(N,M)
ans=1
for i in range(1,min_+1):
    ans=(ans*i)%p
    ans=(ans*i)%p

if abs_NM==1:
    ans=(ans*max_)%p
else:
    ans=(ans*2)%p

print(ans)

#
# abc065 c
#
import sys
from io import StringIO
import unittest
import math


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """2 2"""
        output = """8"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """3 2"""
        output = """12"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """1 8"""
        output = """0"""
        self.assertIO(input, output)

    def test_入力例_4(self):
        input = """100000 100000"""
        output = """530123477"""
        self.assertIO(input, output)


def resolve():
    N, M = list(map(int, input().split()))

    if abs(N-M) > 1:
        print("0")
    elif N == M:
        print((2*math.factorial(N)*math.factorial(M) % (10**9+7)))
    else:
        print((math.factorial(N)*math.factorial(M) % (10**9+7)))


def __starting_point():
    # unittest.main()
    resolve()

__starting_point()

import math
n, m = map(int, input().split())
p = 10**9 + 7



nf = math.factorial(n) % p
mf = math.factorial(m) % p

if abs(n-m) > 1:
  ans = 0

elif n == m:
  ans = nf * mf * 2
  
else:
  ans = nf * mf
  
print(ans % p)

from math import factorial
n,m=map(int,input().split())
l=10**9+7
if abs(n-m)>1:
  print(0)
  return
if abs(n-m)==1:
  print((factorial(n)*factorial(m))%l)
else:
  print(((factorial(n)**2)*2)%l)

import sys


def LI():
    return list(map(int, input().split()))


N, M = LI()
if abs(N-M) >= 2:
    print((0))
    return
mod = pow(10, 9)+7
x = 1
if N == M:
    for i in range(1, N+1):
        x = (x*i) % mod
    ans = (x*x*2) % mod
else:
    A = max(N, M)
    B = min(N, M)
    for i in range(1, B+1):
        x = (x*i) % mod
    y = (x*A) % mod
    ans = (x*y) % mod
print(ans)


n,m=[int(i) for i in input().split()]
new_n=min(n,m)
new_m=max(n,m)
mod=10**9+7
def ans(n,m):

    if n==m:
        return 2*kaijyou(n,mod)*kaijyou(m,mod)
    elif m-n==1:
        return kaijyou(n,mod)*kaijyou(m,mod)
    else:
        return 0


def kaijyou(n,mod):
    ans=1
    for i in range(1,n+1):
        ans*=i
        ans=ans%mod
    return ans
print(ans(new_n,new_m)%mod)

import math
mod=10**9+7
n,m=list(map(int,input().split()))
if n+1<m or m+1<n:
    print((0))
    return
elif n==m:
    print(((2*math.factorial(n)**2)%mod))
else:
    print(((math.factorial(n)*math.factorial(m))%mod))



from math import factorial
def count(n, r):
    if n == r:
        return 2
    else:
        return 1

N, M = map(int, input().split())
mod = 10**9 + 7
print(((factorial(N) % mod) * (count(N, M) % mod) * (factorial(M) % mod)) % mod if abs(N - M) < 2 else 0)

n,m = list(map(int, input().split()))
f = [1] 
p = 10**9 + 7
for i in range(1, max(n,m) + 1):
  f.append(f[-1] * i % p)

if abs(n-m) == 1:
  print((f[n] * f[m] % p))
elif abs(n-m) == 0:
  print((f[n] * f[m] * 2 % p))
else:
  print((0))


import math

N, M = list(map(int, input().split()))
if abs(N - M) >= 2:
    print((0))
    return


N = math.factorial(N) % (10 ** 9 + 7)
M = math.factorial(M) % (10 ** 9 + 7)
if N == M:
    print(((N * M * 2) % (10 ** 9 + 7)))
else:
    print(((N * M) % (10 ** 9 + 7)))


import math

n, m = map(int, input().split())
if n==m:
    print((math.factorial(n)*math.factorial(m)*2)%1000000007)
elif abs(n-m)==1:
    print((math.factorial(n)*math.factorial(m))%1000000007)
else:
    print(0)

n, m = list(map(int, input().split()))


def facmod(a, mod):
    res = 1
    for i in range(1, a+1):
        res = (res*i) % mod
    return res


mod = 10**9+7
mn = min(m, n)
mx = max(m, n)
if abs(mn-mx) > 1:
    ans = 0
else:
    if n == m:
        ans = (2*facmod(m, mod)*facmod(n, mod)) % mod
    else:
        ans = (facmod(mx, mod)*facmod(mn, mod)) % mod
print(ans)


def main():
  N, M = [int(n) for n in input().split(" ")]

  if abs(N - M) >= 2:
    print((0))
  elif abs(N - M) == 1:
    print(((factorial(N) * factorial(M)) % 1000000007))
  else:
    print(((factorial(N) * factorial(M) * 2) % 1000000007))

def factorial(n):
  ret = 1
  for i in range(1, n + 1):
    ret = (ret * i) % 1000000007
  return ret
    
main()


N,M=list(map(int,input().strip().split()))
inf=10**9+7
ans=1
for n in range(1,N+1):
    ans*=n
    ans%=inf
for m in range(1,M+1):
    ans*=m
    ans%=inf

if abs(N-M)>=2:
    print((0))
elif abs(N-M)==1:
    print(ans)
else:
    print((ans*2%inf))


import math

n, m = map(int, input().split())
n_f = math.factorial(n)
m_f = math.factorial(m)
mod = 1000000007

if abs(n-m) > 1:
    print(0)
    return
if n == m:
    print((n_f * m_f * 2) % mod)
else:
    print((n_f * m_f) % mod)

def mod1(x):
  mod=10**9+7
  ans=1
  y=1
  while y<=x:
    ans=ans*y
    y+=1
    ans=ans%mod
    
  return ans%mod

n,m=map(int,input().split())
if n==m:
  print((2*mod1(n)*mod1(m))%(10**9+7))
elif abs(n-m)==1:
  print((mod1(n)*mod1(m))%(10**9+7))
else:
  print(0)

from math import factorial
n,m=list(map(int,input().split()))
if abs(n-m)>1:
    print((0))
    return
mod=10**9+7
if n==m:
    print(((2*factorial(n)*factorial(m))%mod))
else:
    print(((factorial(n)*factorial(m))%mod))


from math import factorial
n,m=map(int,input().split())
l=10**9+7
if abs(n-m)>1:
  print(0)
  return
if abs(n-m)==1:
  print((factorial(n)*factorial(m))%l)
else:
  print(((factorial(n)**2)*2)%l)

n,m=list(map(int,input().split()))
p=10**9+7
if abs(n-m)>=2:
    print((0))
elif n==m:
    ans=1
    for i in range(1,n+1):
        ans=(ans*i)%p
    print(((2*ans*ans)%p))
else:
    ans=1
    for i in range(1,n+1):
        ans=(ans*i)%p
    for i in range(1,m+1):
        ans=(ans*i)%p
    print((ans%p))


def factorial(n, mod):
    num = 1
    for i in range(1, n + 1):
        i %= mod
        num *= i
        num %= mod
    return num


def main():
    n, m = map(int, input().split())
    md = 10 ** 9 + 7

    if abs(n - m) >= 2:
        ans = 0
    elif abs(n - m) == 1:
        ans = (factorial(n, md) * factorial(m, md))
        ans %= md
    else:
        ans = (factorial(n, md) * factorial(m, md)) * 2
        ans %= md

    print(ans)


def __starting_point():
    main()
__starting_point()

from math import factorial
n, m = map(int, input().split())
if n == m:
    print(factorial(n)*factorial(m)*2 % (10**9+7))
elif abs(n-m) <= 1: 
    print(factorial(n)*factorial(m) % (10**9+7))
else:
    print(0)

def gyakugen(x,p):
  binp = str(bin(p-2))[::-1]
  ruijou = x
  
  result = 1
  for i in range(len(binp)-2):
    if binp[i] == "1":
      result *= ruijou
      result %= p
    ruijou *= ruijou
    ruijou %= mod
  return result

N, M = [int(i) for i in input().split()]
mod = 10**9+7

if abs(N-M) > 1 :
  print(0)
  return
elif N == M:
  ans = 1
  for i in range(1,N+1):
    ans *= i
    ans %= mod
    ans *= i
    ans %= mod
  ans *= 2
  ans %= mod
  print(ans)
else:
  ans = 1
  m = min(N,M)
  for i in range(1,m+1):
    ans *= i
    ans %= mod
    ans *= i
    ans %= mod
  ans *= max(N,M)
  ans %= mod
  print(ans)

from math import factorial

n, m = map(int, input().split())
if n == m:
    ans = factorial(n) % (10 ** 9 + 7)
    ans = ans ** 2 % (10 ** 9 + 7)
    print(ans * 2 % (10 ** 9 + 7))
elif abs(n - m) == 1:
    ans1 = factorial(n) % (10 ** 9 + 7)
    ans2 = factorial(m) % (10 ** 9 + 7)
    print(ans1 * ans2 % (10 ** 9 + 7))
else:
    print(0)

N, M = map(int,input().split())
ans = 1
if abs(N-M) >= 2:
    ans = 0
elif N == M:
    for i in range(1,M+1):
        ans = (ans*i) % (10**9+7)
    for i in range(1,M+1):
        ans = (ans*i) % (10**9+7)
    ans = (ans*2) % (10**9+7)
else:
    for i in range(1,M+1):
        ans = (ans*i) % (10**9+7)
    for i in range(1,N+1):
        ans = (ans*i) % (10**9+7)
print(ans)

# C - Reconciled?
def main():
    from math import factorial

    n, m = map(int, input().split())
    p = 10**9+7

    if abs(n-m) < 2:
        if n == m:
            print(2*factorial(n)*factorial(m)%p)
        else:
            print(factorial(n)*factorial(m)%p)
    else:
        print(0)

if __name__ ==  "__main__":
    main()