Problem:
Score : 300 points

Problem Statement

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 1

2 2

Sample Output 1

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.

Sample Input 2

3 2

Sample Output 2

12

Sample Input 3

1 8

Sample Output 3

0

Sample Input 4

100000 100000

Sample Output 4

530123477

Solution in Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"fmt"
	"log"
)

func main() {
	log.SetFlags(log.Lshortfile)
	var N, M int
	fmt.Scan(&N, &M)
	getFactInv()
	if abs(N-M) >= 2 {
		fmt.Println("0")
	} else if abs(N-M) == 1 {
		fmt.Println(p(N, N) * p(M, M))
	} else if N == M {
		fmt.Println(p(N, N) * p(M, M) % MOD * 2 % MOD)
	} else {
		fmt.Println("0")
	}

}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

const MAX = 2000010

var MOD int = 1000000007 // 素数
var fact [MAX]int        // 階乗
var factInv [MAX]int     // 階乗の逆元
var inv [MAX]int

func getFactInv() {
	// 最初に一度だけ実行
	inv[1], fact[0], factInv[0] = 1, 1, 1
	// nHkはn+k+1Ckとなるためn+kをとる
	var i int
	for i = 2; i < MAX; i++ {
		inv[i] = inv[MOD%i] * (MOD - MOD/i) % MOD
	}
	for i = 1; i < MAX; i++ {
		fact[i] = fact[i-1] * i % MOD
		factInv[i] = factInv[i-1] * inv[i] % MOD
	}
}

// 1 以上 N 以下の N 個の整数の中から，相異なる K 個の整数を選ぶパターンの数を C(N,K) と書きます．
func c(n, k int) int {
	if k < 0 || k > n {
		return 0
	}
	return fact[n] * factInv[k] % MOD * factInv[n-k] % MOD
}

// 1 以上 N 以下の N 個の整数の中から，相異なる K 個の整数を選び，順番に並べるパターンの数を P(N,K) と書きます．
// p(N, N)のときN!
func p(n, k int) int {
	if k < 0 || k > n {
		return 0
	}
	return fact[n] * factInv[n-k] % MOD
}

// 1 以上 N 以下の N 個の整数の中から，重複を許して K 個の整数を選ぶパターンの数を H(N,K) と書きます．
func h(n, k int) int {
	if n == 0 && k == 0 {
		return 1
	}
	if n == 0 {
		return 0
	}
	return c(n+k-1, k)
}