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
/**
 * @author derrick20
 */
import java.io.*;
import java.util.*;

public class PlacingRooks {
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);

        int N = sc.nextInt();
        long k = sc.nextLong();

        factorial = new long[N + 1];
        invFact = new long[N + 1];
        factorial[0] = 1;
        invFact[0] = 1;
        for (int i = 1; i <= N; i++) {
            factorial[i] = ((long) i * factorial[i - 1]) % mod;
            invFact[i] = fastExpo(factorial[i], mod - 2);
        }

        /*
        We can eliminate the simple cases first. Notice that we use either all
        columns or all rows. By contradiction, if we didn't then the missing
        col + missing row would highlight a square that is not being attacked!

        From there, we now constructively count the ways. We can count ways
        for each row to be occupied, then double it for the ways the columns
        are all occupied. The case where the overlap is a simple answer,
        namely N!, so we handle that easily. Otherwise, they are disjoint!

        With each row, we must select some group of N - K columns (with each
        extra K, we essentially glue together two of the rooks from two rows,
        which decreases the degrees of freedom for the number of distinct
        columns occupied. So, however many K intersections is however many
        columns we lose.
        We do this part in N choose N-K ways.

        Now, we need to assign each row's rook to one of these columns in an
        onto fashion (each column must possess a rook, because then otherwise
        we would be having EXTRA attacks (the number of columns missing is
        a bijection to the number of attacking pairs)

        So, we need to count the number of onto functions from N rows to N-K
        columns. We can do this with inclusion-exclusion. We sum the number
        of ways for us to be able to choose from all N-K columnes, subtract
        ways to choose from N-K-1, add N-K-2,... And that's it!
         */

        if (k >= N) {
            out.println(0);
        }
        else if (k == 0) {
            out.println(factorial[N]);
        }
        else {
            long onto = 0;
            int K = (int) k; // we KNOW it's an int now
            for (int i = 0; i <= N - K; i++) {
                long addend = (choose(N - K, i) * fastExpo(N - K - i, N) % mod);
                onto += (addend * (i % 2 == 0 ? 1 : mod - 1)) % mod;
                onto %= mod;
            }
            // x2 because flipping to columns now
            long ans = (2 * choose(N, K) * onto) % mod;
            out.println(ans);
        }

        out.close();
    }

    static long mod = 998244353;

    static long[] factorial, invFact;

    static long choose(int N, int K) {
        long res = (factorial[N] * invFact[K]) % mod;
        res = (res * invFact[N - K]) % mod;
        return res;
    }

    static long fastExpo(long x, long k) {
        if (k == 0) {
            return 1;
        }
        else if (k == 1) {
            return x;
        }
        else {
            long root = fastExpo(x, k / 2);
            long ans = (root * root) % mod;
            if (k % 2 == 1) {
                ans = (ans * x) % mod;
            }
            return ans;
        }
    }

    static class FastScanner {
        private int BS = 1<<16;
        private char NC = (char)0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;

        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }

        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            }
            catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }

        private char getChar(){
            while(bId==size) {
                try {
                    size = in.read(buf);
                }catch(Exception e) {
                    return NC;
                }
                if(size==-1)return NC;
                bId=0;
            }
            return (char)buf[bId++];
        }

        public int nextInt() {
            return (int)nextLong();
        }

        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }

        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }

        public long nextLong() {
            cnt=1;
            boolean neg = false;
            if(c==NC)c=getChar();
            for(;(c<'0' || c>'9'); c = getChar()) {
                if(c=='-')neg=true;
            }
            long res = 0;
            for(; c>='0' && c <='9'; c=getChar()) {
                res = (res<<3)+(res<<1)+c-'0';
                cnt*=10;
            }
            return neg?-res:res;
        }

        public double nextDouble() {
            double cur = nextLong();
            return c!='.' ? cur:cur+nextLong()/cnt;
        }

        public String next() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c>32) {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c!='\n') {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public boolean hasNext() {
            if(c>32)return true;
            while(true) {
                c=getChar();
                if(c==NC)return false;
                else if(c>32)return true;
            }
        }
    }
}