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)

use std::io::*;
use std::str::FromStr;
use std::cmp::{max, min};

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("faild to read char") as char)
        .take_while(|c| !c.is_whitespace())
        .collect();
    token
        .parse()
        .ok()
        .expect("faild to parse token")
}

fn main(){
    let x: u64 = read();
    let y: u64 = read();

    if (x + y) % 3 != 0 {
        println!("0");
        return;
    }

    let sum = (x + y) / 3;
    let sub = max(x, y) - min(x, y);
    let c = (sum + sub) / 2;
    let d = (sum - sub) / 2;
    //println!("{} {}", c, d);
    // println!("{} {}", sum, sub);

    let mut ret = 1;
    for i in 0..c {
        ret = (ret * (d + c - i)) % MOD;
        //println!("{}", ret);
        ret = (ret * inverse(i + 1)) % MOD;
        //println!("{}", ret);
        //println!("{}", inverse(d + c - i) * (d + c - i) % MOD);
        //println!("{} {}", ret, i);
    }
    println!("{}", ret);
}

const MOD: u64 = 1000000007;

fn pow(base: u64, exp: u64) -> u64 {
    if exp == 1 {
        return base;
    } else if exp == 0 {
        return 1;
    } else if exp % 2 == 0 {
        let prev = pow(base, exp / 2);
        return (prev * prev) % MOD;
    } else {
        let prev = pow(base, exp / 2);
        return (((prev * prev) % MOD) * base) % MOD;
    }
}

fn inverse(n: u64) -> u64 {
    pow(n, MOD - 2)
}