Problem: Getting closer and closer to a mathematician, Serval becomes a university student on math major in Japari University. On the Calculus class, his teacher taught him how to calculate the expected length of a random subsegment of a given segment. Then he left a bonus problem as homework, with the award of a garage kit from IOI. The bonus is to extend this problem to the general case as follows.

You are given a segment with length l. We randomly choose n segments by choosing two points (maybe with non-integer coordinates) from the given segment equiprobably and the interval between the two points forms a segment. You are given the number of random segments n, and another integer k. The 2n endpoints of the chosen segments split the segment into (2n+1) intervals. Your task is to calculate the expected total length of those intervals that are covered by at least k segments of the n random segments.

You should find the answer modulo 998244353.

Input

First line contains three space-separated positive integers n, k and l (1≤ k ≤ n ≤ 2000, 1≤ l≤ 10^9).

Output

Output one integer — the expected total length of all the intervals covered by at least k segments of the n random segments modulo 998244353.

Formally, let M = 998244353. It can be shown that the answer can be expressed as an irreducible fraction p/q, where p and q are integers and q not ≡ 0 \pmod{M}. Output the integer equal to p ⋅ q^{-1} mod M. In other words, output such an integer x that 0 ≤ x < M and x ⋅ q ≡ p \pmod{M}.

Examples

Input


1 1 1


Output


332748118


Input


6 2 1


Output


760234711


Input


7 5 3


Output


223383352


Input


97 31 9984524


Output


267137618

Note

In the first example, the expected total length is \int_0^1 \int_0^1 |x-y|  dx dy = {1\over 3}, and 3^{-1} modulo 998244353 is 332748118.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        ServalAndBonus solver = new ServalAndBonus();
        solver.solve(1, in, out);
        out.close();
    }

    static class ServalAndBonus {
        long MOD = 998244353;
        long[] inv = new long[5005];
        long[] pow = new long[5005];
        long LVL = (long) (8e18);

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            int K = in.nextInt();
            long l = in.nextInt();
            long invL = MathUtils.inverse(l, MOD);
            for (int i = 1; i < inv.length; i++) {
                inv[i] = MathUtils.inverse(i, MOD);
            }
            pow[0] = 1;
            for (int i = 1; i < pow.length; i++) {
                pow[i] = pow[i - 1] * l;
                pow[i] %= MOD;
                pow[i] %= MOD;
            }
            for (int i = 0; i < pow.length; i++) {
                pow[i] *= inv[i];
                pow[i] %= MOD;
            }
            long invL2 = (invL * invL) % MOD;
            long res = 0;
            long[] poly = new long[]{l, -1 + MOD};
            long[] other = new long[]{(l * l) % MOD, MathUtils.mod(-2 * l, MOD), 2};
            long[] cur = new long[4005];
            cur[0] = 1;
            for (int i = 0; i < N; i++) {
                for (int j = cur.length - 2; j >= 0; j--) {
                    cur[j] = cur[j] * poly[0] + (j - 1 >= 0 ? cur[j - 1] * poly[1] : 0);
                    cur[j] %= MOD;
                    cur[j + 1] = cur[j];
                    cur[j] = 0;
                }
            }
            long comb = 1;
            for (int i = N; i >= K; i--) {
                long now = 0;
                for (int j = 0; j < cur.length; j++) {
                    now += pow[j + 1] * cur[j];
                    if (Math.abs(now) >= LVL) {
                        now %= MOD;
                    }
                }
                now %= MOD;
                now *= MathUtils.binPow(2, i, MOD);
                now %= MOD;
                now *= comb;
                now %= MOD;
                res += now;
                if (res >= MOD) {
                    res -= MOD;
                }
                for (int j = cur.length - 1; j >= 0; j--) {
                    cur[j] = cur[j] * other[0];
                    for (int k = 1; k <= 2; k++) {
                        if (j - k >= 0) {
                            cur[j] += cur[j - k] * other[k];
                        }
                    }
                    cur[j] %= MOD;
                }
                long val = cur[cur.length - 1];
                for (int j = cur.length - 1; j >= 1; j--) {
                    cur[j] = -val + MOD;
                    val = cur[j - 1] + l * val;
                    val %= MOD;
                }
                for (int j = 0; j < cur.length - 1; j++) {
                    if (j + 2 >= cur.length) {
                        cur[j] = 0;
                    } else {
                        cur[j] = cur[j + 2];
                    }
                }
                comb *= inv[N - i + 1];
                comb %= MOD;
                comb *= i;
                comb %= MOD;
            }
            res *= MathUtils.binPow(invL2, N, MOD);
            res %= MOD;
            out.println(res);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }

    static class MathUtils {
        public static long inverse(long a, long mod) {
            long[] inv = extended_gcd(a, mod);
            if (inv[0] != 1) {
                return 0;
            } else {
                return (inv[1] + 2 * mod) % mod;
            }
        }

        public static long[] extended_gcd(long a, long b) {
            //three numbers, first is gcd, second is x, third is y
            if (a == 0) {
                return new long[]{b, 0, 1};
            }
            long[] next = extended_gcd(b % a, a);
            long tempX = next[1];
            next[1] = next[2] - (b / a) * next[1];
            next[2] = tempX;
            return next;
        }

        public static long binPow(long b, long p, long mod) {
            long res = 1;
            while (p > 0) {
                if ((p & 1) == 1) {
                    res *= b;
                    res %= mod;
                }
                b = b * b;
                p >>= 1;
                b %= mod;
            }
            return res;
        }

        public static long mod(long a, long mod) {
            return (a + (Math.abs(a) + mod - 1) / mod * mod) % mod;
        }

    }
}