import sys
MOD = 998244353

def main():
    N, B, C = map(int, sys.stdin.readline().split())

    # Precompute factorial and inverse factorial modulo MOD
    max_n = N
    fact = [1] * (max_n + 1)
    for i in range(1, max_n + 1):
        fact[i] = fact[i - 1] * i % MOD
    inv_fact = [1] * (max_n + 1)
    inv_fact[max_n] = pow(fact[max_n], MOD - 2, MOD)
    for i in range(max_n - 1, -1, -1):
        inv_fact[i] = inv_fact[i + 1] * (i + 1) % MOD

    def comb(s):
        if s < 0 or s > N:
            return 0
        return fact[N] * inv_fact[s] % MOD * inv_fact[N - s] % MOD

    # Precompute comb_cache for 0 <= s <= N
    comb_cache = [comb(s) for s in range(N + 1)]

    dp = {0: 1}
    for k in range(61):
        new_dp = dict()
        Bk = (B >> k) & 1
        Ck = (C >> k) & 1
        for c_in, ways in dp.items():
            # Check if the condition Ck == (Bk - c_in) mod 2
            if (Ck != (Bk - c_in) % 2):
                continue
            # Calculate possible c_out range
            numerator_min = c_in - Bk
            c_out_min = max(0, (numerator_min + 1) // 2)
            numerator_max = N + c_in - Bk
            c_out_max = numerator_max // 2

            if c_out_min > c_out_max:
                continue

            for c_out in range(c_out_min, c_out_max + 1):
                s = 2 * c_out + Bk - c_in
                if s < 0 or s > N:
                    continue
                comb_val = comb_cache[s]
                new_dp[c_out] = (new_dp.get(c_out, 0) + ways * comb_val) % MOD

        dp = new_dp

    print(dp.get(0, 0) % MOD)

if __name__ == "__main__":
    main()