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 Kotlin (1.0.0) (judge verdict: Wrong Answer)

import java.util.*

const val mod = 1000000007L
fun main(args: Array<String>) {
    val (x, y) = readLine()!!.split(" ").map { it.toInt() }

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

    val n = ((x + y) / 3).toLong()
    val k = Math.min(x, y) - n
    println(" :: $n $k")

    if (k < 0) {
        println(0)
        return
    }

    println("1: $n ${factorial(n)}")
    println("2: ${n-k} ${factorial(n-k)}")
    println("3: ${inverse(factorial(n - k))}")


    var r = factorial(n)
    var a = factorial(k)
    var b = factorial(n - k)
    var c = (a * b) % mod
    var d = inverse(c)
    var e = (r * d) % mod

    //println("$a $b $c $d $e")
    println(e)
}

fun factorial(n: Long): Long {
    var r = 1L
    (1..n).forEach { r = (r * it) % mod }
    return r
}

fun inverse(n: Long): Long {
    return pow(n, mod - 2)
}

fun pow(n: Long, k: Long): Long { // n ^ k
    if (k == 0L) return 1
    if (k == 1L) return n

    val res = pow(n, k / 2)
    var r = (res * res) % mod
    if (k % 2 == 1L) r = (r * n) % mod
    return r
}