Calculate the number of ways to place n rooks on n × n chessboard so that both following conditions are met:

  * each empty cell is under attack; 
  * exactly k pairs of rooks attack each other. 



An empty cell is under attack if there is at least one rook in the same row or at least one rook in the same column. Two rooks attack each other if they share the same row or column, and there are no other rooks between them. For example, there are only two pairs of rooks that attack each other in the following picture:

<image> One of the ways to place the rooks for n = 3 and k = 2

Two ways to place the rooks are considered different if there exists at least one cell which is empty in one of the ways but contains a rook in another way.

The answer might be large, so print it modulo 998244353.

Input

The only line of the input contains two integers n and k (1 ≤ n ≤ 200000; 0 ≤ k ≤ (n(n - 1))/(2)).

Output

Print one integer — the number of ways to place the rooks, taken modulo 998244353.

Examples

Input


3 2


Output


6


Input


3 3


Output


0


Input


4 0


Output


24


Input


1337 42


Output


807905441
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.function.*;
import java.util.function.IntPredicate;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
import java.util.stream.*;


public class E {

    private static final FastReader in = new FastReader();
    private static final FastWriter out = new FastWriter();

    public static void main(String[] args) {
        new E().run();
    }

    private void run() {
        var t = 1;
        while (t-- > 0) {
            solve();
        }

        out.flush();
    }

    private void solve() {
        var n = in.nextInt();
        var kt = in.nextLong();

        if (kt >= n) {
            out.println(0);
            return;
        }

        var k = (int) kt;
        var mod = new Modulo(998244353);
        var facts = mod.factorials(n);

        var ans = 0L;
        var c = n - k;
        for (var i = 0; i <= c; i++) {
            var t = mod.times(mod.combination(c, i, facts), mod.pow(c - i, n));
            if (i % 2 == 0) {
                ans = mod.plus(ans, t);
            } else {
                ans = mod.minus(ans, t);
            }
        }
        ans = mod.times(ans, mod.combination(n, n - k, facts));

        if (k > 0) ans = mod.times(ans, 2);
        out.println(ans);
    }

}


class FastReader {

    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer in;

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

    public BigDecimal nextBigDecimal() {
        return new BigDecimal(next());
    }

    public BigInteger nextBigInteger() {
        return new BigInteger(next());
    }

    public boolean nextBoolean() {
        return Boolean.valueOf(next());
    }

    public byte nextByte() {
        return Byte.valueOf(next());
    }

    public double nextDouble() {
        return Double.valueOf(next());
    }

    public double[] nextDoubleArray(int length) {
        var a = new double[length];
        for (var i = 0; i < length; i++) {
            a[i] = nextDouble();
        }
        return a;
    }

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

    public int[] nextIntArray(int length) {
        var a = new int[length];
        for (var i = 0; i < length; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    public long nextLong() {
        return Long.valueOf(next());
    }

    public long[] nextLongArray(int length) {
        var a = new long[length];
        for (var i = 0; i < length; i++) {
            a[i] = nextLong();
        }
        return a;
    }

}


class FastWriter extends PrintWriter {

    public FastWriter() {
        super(System.out);
    }

    public void println(boolean[] a) {
        for (var i = 0; i < a.length; i++) {
            print(a[i]);
            print(i + 1 < a.length ? ' ' : '\n');
        }
    }

    public void println(double[] a) {
        for (var i = 0; i < a.length; i++) {
            print(a[i]);
            print(i + 1 < a.length ? ' ' : '\n');
        }
    }

    public void println(int[] a) {
        for (var i = 0; i < a.length; i++) {
            print(a[i]);
            print(i + 1 < a.length ? ' ' : '\n');
        }
    }

    public void println(long[] a) {
        for (var i = 0; i < a.length; i++) {
            print(a[i]);
            print(i + 1 < a.length ? ' ' : '\n');
        }
    }

    public void println(Object... a) {
        for (var i = 0; i < a.length; i++) {
            print(a[i]);
            print(i + 1 < a.length ? ' ' : '\n');
        }
    }

    public <T> void println(List<T> l) {
        println(l.toArray());
    }

    public void debug(String name, Object o) {
        String value = Arrays.deepToString(new Object[] { o });
        value = value.substring(1, value.length() - 1);
        System.err.println(name + " => " + value);
    }

}


class MathUtils {

    public static final double EPS = 1e-12;

    public static final Comparator<Double> EPS_COMPARATOR = (x, y) -> {
        if (x + EPS < y) {
            return -1;
        } else if (x - EPS > y) {
            return 1;
        } else {
            return 0;
        }
    };

    public static int compare(double x, double y) {
        return EPS_COMPARATOR.compare(x, y);
    }

    /**
     * Returns the index of the first element in the range <b>[left, right)</b> which <i>leftShouldAdvance</i> tested to
     * be <i>false</i>.
     */
    public static int binarySearch(int left, int right, IntPredicate leftShouldAdvance) {
        while (left < right) {
            var mid = left + (right - left) / 2;
            if (leftShouldAdvance.test(mid)) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }

        return left;
    }

    /**
     * Returns the index of the first element in <i>a</i> which >= <i>x</i>.
     */
    public static int lowerBound(int[] a, int x) {
        return binarySearch(0, a.length, mid -> a[mid] < x);
    }

    public static int lowerBound(long[] a, long x) {
        return binarySearch(0, a.length, mid -> a[mid] < x);
    }

    /**
     * Returns the index of the first element in <i>a</i> which > <i>x</i>.
     */
    public static int upperBound(int[] a, int x) {
        return binarySearch(0, a.length, mid -> a[mid] <= x);
    }

    public static int upperBound(long[] a, long x) {
        return binarySearch(0, a.length, mid -> a[mid] <= x);
    }

    /**
     * Searches for the maximum value of a unimodal function f(x).
     * <p>
     * A function f(x) is a <b>unimodal function</b> if for some value m, it is <b>monotonically increasing</b> for x ≤
     * m and <b>monotonically decreasing</b> for x ≥ m. In that case, the maximum value of f(x) is f(m) and there are no
     * other local maxima.
     */
    public static int ternarySearchMaxInt(int left, int right, IntUnaryOperator f) {
        return binarySearch(left, right, mid -> f.applyAsInt(mid) < f.applyAsInt(Math.min(mid + 1, right - 1)));
    }

    public static int ternarySearchMaxLong(int left, int right, IntToLongFunction f) {
        return binarySearch(left, right, mid -> f.applyAsLong(mid) < f.applyAsLong(Math.min(mid + 1, right - 1)));
    }

    public static long gcd(long a, long b) {
        while (b > 0) {
            var t = a % b;
            a = b;
            b = t;
        }
        return a;
    }

    /**
     * Solves x and y such that ax + by = gcd(a, b).
     */
    public static long extendedEuclidean(long a, long b, long[] xy) {
        if (b == 0L) {
            xy[0] = 1L;
            xy[1] = 0L;

            return a;
        }

        var r = extendedEuclidean(b, a % b, xy);
        var t = xy[0];
        xy[0] = xy[1];
        xy[1] = t - a / b * xy[1];

        return r;
    }

    public static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

}

// all a, b < mod
class Modulo {

    private final long mod;

    public Modulo(long mod) {
        this.mod = mod;
    }

    public long plus(long a, long b) {
        var c = a + b;
        if (c >= mod) {
            c -= mod;
        }
        return c;
    }

    public long minus(long a, long b) {
        var c = a - b;
        if (c < 0) {
            c += mod;
        }
        return c;
    }

    public long times(long a, long b) {
        return a * b % mod;
    }

    public long div(long a, long b) {
        return times(a, pow(b, mod - 2));
    }

    public long pow(long a, long b) {
        long c = 1;

        while (b > 0) {
            if ((b & 1) > 0) {
                c = c * a % mod;
            }
            a = a * a % mod;
            b >>= 1;
        }

        return c;
    }

    public long combination(int n, int k) {
        return div(factorial(n), times(factorial(k), factorial(n - k)));
    }

    public long combination(int n, int k, long[] factorials) {
        return div(factorials[n], times(factorials[k], factorials[n - k]));
    }

    public long factorial(int n) {
        var f = 1L;
        for (var i = 1; i <= n; i++) {
            f = f * i % mod;
        }
        return f;
    }

    public long[] factorials(int n) {
        var f = new long[n + 1];
        f[0] = 1L;
        for (var i = 1; i <= n; i++) {
            f[i] = f[i - 1] * i % mod;
        }
        return f;
    }

}
