public class Euler837 {
    static final long kMod = 1234567891L;
    static final long kInv3 = 823045261L;
    static final int kBlock = 8000000;

    static long modPow(long base, long exp) {
        long out = 1;
        base %= kMod;
        while (exp > 0) {
            if ((exp & 1) == 1)
                out = (out * base) % kMod;
            base = (base * base) % kMod;
            exp >>= 1;
        }
        return out;
    }

    static long modInv(long x) {
        return modPow(x, kMod - 2);
    }

    static long[] inverseRange(long start, int len) {
        if (len == 0)
            return new long[0];
        long[] pref = new long[len];
        long cur = start % kMod;
        pref[0] = cur;
        for (int i = 1; i < len; ++i) {
            if (++cur == kMod)
                cur = 0;
            pref[i] = (pref[i - 1] * cur) % kMod;
        }

        long invProd = modInv(pref[len - 1]);
        cur = (start + len - 1) % kMod;

        for (int i = len - 1; i >= 0; --i) {
            long prev = (i == 0) ? 1 : pref[i - 1];
            pref[i] = (invProd * prev) % kMod;
            invProd = (invProd * cur) % kMod;
            if (cur == 0)
                cur = kMod - 1;
            else
                --cur;
        }
        return pref;
    }

    static long binomMod(long n, long k) {
        if (k > n)
            return 0;
        k = Math.min(k, n - k);
        if (k == 0)
            return 1;

        long out = 1;
        long offset = n - k;

        for (long l = 1; l <= k; l += kBlock) {
            long r = Math.min(k, l + kBlock - 1);
            int len = (int) (r - l + 1);
            long[] invs = inverseRange(l, len);
            long num = (offset + l) % kMod;
            for (int i = 0; i < len; ++i) {
                out = (out * num) % kMod;
                out = (out * invs[i]) % kMod;
                if (++num == kMod)
                    num = 0;
            }
        }
        return out;
    }

    static long solve(long m, long n) {
        if (((m + n) & 1) == 1)
            return 0;

        long t = (m + n) >> 1;
        long parity = m & 1;
        long maxK = Math.min(m, n);

        long k = parity;
        long a = (m - parity) >> 1;
        long b = (n - parity) >> 1;

        long weight = 0;
        if (parity == 0) {
            weight = binomMod(t, a);
        } else {
            weight = ((t % kMod) * binomMod(t - 1, a)) % kMod;
        }

        long pow2k = (parity == 0) ? 1 : 2;
        long signPart = (parity == 0) ? 2 : (kMod - 2);

        long answer = 0;

        long f3 = pow2k + signPart;
        if (f3 >= kMod)
            f3 -= kMod;
        f3 = (f3 * kInv3) % kMod;
        long inc = (weight * f3) % kMod;
        answer = (answer + inc) % kMod;

        if (k == maxK)
            return answer;

        long updates = (maxK - k) >> 1;
        long aMod = a % kMod;
        long bMod = b % kMod;

        while (updates > 0) {
            int len = (int) Math.min(updates, kBlock);
            long[] invs = inverseRange(k + 1, 2 * len);

            for (int i = 0; i < len; ++i) {
                long invK1 = invs[2 * i];
                long invK2 = invs[2 * i + 1];

                weight = (weight * aMod) % kMod;
                weight = (weight * bMod) % kMod;
                weight = (weight * invK1) % kMod;
                weight = (weight * invK2) % kMod;

                --a;
                --b;
                if (aMod == 0)
                    aMod = kMod - 1;
                else
                    --aMod;
                if (bMod == 0)
                    bMod = kMod - 1;
                else
                    --bMod;
                k += 2;
                pow2k = (pow2k * 4) % kMod;

                f3 = pow2k + signPart;
                if (f3 >= kMod)
                    f3 -= kMod;
                f3 = (f3 * kInv3) % kMod;
                inc = (weight * f3) % kMod;
                answer = (answer + inc) % kMod;
            }
            updates -= len;
        }

        return answer;
    }

    public static String solveStr() {
        return Long.toString(solve(123456789L, 987654321L));
    }

    public static void main(String[] args) {
        System.out.println(solveStr());
    }
}