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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	int R,C,N;
	ArrayList<Integer> edge;

	private void solve() {
		
		System.out.println("YES");
		/*
		// input
		Scanner io = new Scanner(System.in);
		R = io.nextInt();
		C = io.nextInt();
		N = io.nextInt();
		
		edge = new ArrayList<Integer>();
		edge.add(-1);

		boolean ans = true;
		for(int i=0;i<N;i++){
			int x1 = io.nextInt();
			int y1 = io.nextInt();
			int x2 = io.nextInt();
			int y2 = io.nextInt();
			
			int p1 = trans(x1,y1);
			int p2 = trans(x2,y2);
			if(p1==-1||p2 ==-1) continue;
				
			int near1 = solveBS(0,edge.size(),p1);
			int near2 = solveBS(0,edge.size(),p2);
			
			if(near1!=near2){
				if(near1==0){
					int temp = solveBS(0,edge.size(),2*R+2*C);
					if(temp!=near2){
						ans = false;
						continue;
					}
				} else if(near2==0){
					int temp = solveBS(0,edge.size(),2*R+2*C);
					if(temp!=near1){
						ans = false;
						continue;
					}
				} else {
					ans = false;
					continue;
				}
			}
			edge.add(near1+1,Math.min(p1, p2));
			edge.add(near1+2,Math.max(p1, p2));
		}

		System.out.println((ans)?"YES":"NO");*/
	}

	private int solveBS(int left, int right,int targ){// left-OK right-notOK
		//bottom
		if(right-left<=1){
			return left;
		}
		// recursion
		int next = (left + right) / 2;
		if(checkNext(next,targ)){// OK -> right
			return solveBS(next,right,targ);
		}else{ // notOK -> left
			return solveBS(left,next,targ);
		}
	}
	
	private boolean checkNext(int next,int targ){
		return edge.get(next)<=targ;
	}
	
	private int trans(int x,int y){
		if(y==0){
			return x;
		}else if(x==R){
			return R+y;
		}else if(y==C){
			return 2*R+C-x;
		}else if(x==0){
			return 2*R+2*C-y;
		}else{
			return -1;
		}
	}
	
	public static void main(String[] args) {
		new Main().solve();
	}
}