Problem:
Score : 400 points

Problem Statement

There is a knight - the chess piece - at the origin (0, 0) of a two-dimensional grid.

When the knight is at the square (i, j), it can be moved to either (i+1,j+2) or (i+2, j+1).

In how many ways can the knight reach the square (X, Y)?

Find the number of ways modulo 10^9 + 7.

Constraints

1 \leq X \leq 10^6

1 \leq Y \leq 10^6

All values in input are integers.

Input

Input is given from Standard Input in the following format:

X Y

Output

Print the number of ways for the knight to reach (X, Y) from (0, 0), modulo 10^9 + 7.

Sample Input 1

3 3

Sample Output 1

2

There are two ways: (0,0) \to (1,2) \to (3,3) and (0,0) \to (2,1) \to (3,3).

Sample Input 2

2 2

Sample Output 2

0

The knight cannot reach (2,2).

Sample Input 3

999999 999999

Sample Output 3

151840682

Print the number of ways modulo 10^9 + 7.

Solution in Go (1.6) (judge verdict: Accepted)

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const mod = 1000000007

func main() {
	stdin.Split(bufio.ScanWords)
	X := getStdin()
	Y := getStdin()

	remainder1 := (2*Y - X)
	remainder2 := (2*X - Y)

	if remainder1 >= 0 && remainder2 >= 0 && remainder1%3 == 0 && remainder2%3 == 0 {
		Goal := factorial(remainder1/3, remainder2/3)
		fmt.Println(int(Goal))
	} else {
		fmt.Println(0)
	}
}

var stdin = bufio.NewScanner(os.Stdin)

func getStdin() int {
	stdin.Scan()
	if err := stdin.Err(); err != nil {
		fmt.Fprintln(os.Stderr, err)
	}
	line, err := strconv.Atoi(stdin.Text())
	if err != nil {
		panic(err)
	}
	return line
}

func getStd() string {
	stdin.Scan()
	if err := stdin.Err(); err != nil {
		fmt.Fprintln(os.Stderr, err)
	}
	line := stdin.Text()
	return line
}

//Combination:b+cCc
func factorial(b int, c int) int {
	var sum, csum, bsum = 1, 1, 1
	for j := 0; j < c; j++ {
		csum = (csum * (c - j)) % mod
		bsum = (bsum * (b + c - j)) % mod
	}
	sum = div(bsum, csum)
	return sum
}

func mul(a int, b int) int {
	return ((a % mod) * (b % mod)) % mod
}

func div(a int, b int) int {
	return mul(a, power(b, mod-2))
}

func power(x int, y int) int {
	if y == 0 {
		return 1
	}
	if y == 1 {
		return x % mod
	}
	a := power(x, y/2) % mod
	if y%2 == 0 {
		b := a * a % mod
		return b
	}
	b := ((a * a) % mod) * x % mod
	return b
}