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 Rust (1.15.1) (judge verdict: Wrong Answer)

const BIG: usize = 1000000007;

macro_rules! scan {
    ( $( $x:ident ),*; $t:ty ) => {
        let mut buf = String::new();
        let mut itr = {
            while buf.trim().len() == 0 {
                buf = String::new();
                std::io::stdin().read_line(&mut buf).unwrap();
            }
            buf.split_whitespace().map(|n| n.parse::<$t>().unwrap())
        };
        $(
            let $x = itr.next().unwrap();
        )*
    };
}

/*
fn choose(n: usize, k: usize, book: &mut Vec<Vec<u64>>) -> u64 {
    if book[n][k] <= 0 {
        book[n][k] = if k > 0 && n > k { (choose(n-1, k, book) % BIG + choose(n-1, k-1, book) % BIG) % BIG } else { 1 };
    }

    book[n][k]
}
 */

fn fact(start: usize, end: usize) -> usize {
    let mut res = start;
    for j in (start+1)..(end+1) {
        res = (res * j) % BIG;
    }
    res
}

fn choose(n: usize, k: usize) -> usize {
    let a = fact(n, k+1);
    let b = fact(1, n-k);
    a / b
}

fn main() {
    scan!(x, y; i32);

    let t = 2 * x - y;
    let u = 2 * y - x;

    if  t < 0 || u < 0 || t % 3 != 0 || u % 3 != 0 {
        println!("0");
        return;
    }

    let n = (t / 3) as usize;
    let m = (u / 3) as usize;
    let p = n+m;

    println!("{}", choose(p, n));
}