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.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class EducationalRound86E {

	public static long mod = 998244353;
	public static int max = (int)4e5+10;
	public static long[] fact;
	public static long[] infact;
	
	public static void PreCompute() {
		fact = new long[max];
		infact = new long[max];
		fact[0] = fact[1] = infact[0] = infact[1] = 1;
		for(int i = 2; i < max; i++) {
			fact[i] = (fact[i - 1] * (long)i)%mod;
			infact[i] = (infact[i - 1] * (long)ModInverse(i, mod))%mod;
		}
	}
	
	public static long nCr(int n, int r) {
		long ans = fact[n] * infact[r];
		ans %= mod;
		ans *= infact[n - r];
		ans %= mod;
		return ans;
	}
	
	public static long fast(long a, long n) {
		if(n == 0) return 1L;
		long ans = fast(a, n/2L);
		ans = ans * ans;
		ans %= mod;
		if(n%2 == 1) {
			ans = ans * a;
			ans %= mod;
		}
		return ans;
	}
	
	public static void solve() {
		PreCompute();
		int n = s.nextInt();
		long k = s.nextLong();
		if(k == 0) {
			out.println(fact[n]);
			return;
		}
		if(n <= k) {
			out.println(0);
			return;
		}
		long ans = nCr(n, (int)k);
		int cols = n - (int)k;
		long sum = 0;
		for(int i = 0; i <= cols; i ++) {
			long tempans = nCr(cols, i);
			tempans *= fast(cols - i, n);
			tempans %= mod;
			if((i&1)==1) {
				sum -= tempans;
				if(sum < 0) sum += mod;
			}else {
				sum+=tempans;
				if(sum >= mod) sum -= mod;
			}
		}
		out.println((2 * ((ans * sum)%mod))%mod);
	}

	public static void main(String[] args) {
		out = new PrintWriter(new BufferedOutputStream(System.out));
		s = new FastReader();
		solve();
		out.close();
	}

	public static class Triplet {
		long gcd;
		long x;
		long y;

		Triplet(long gcd, long x, long y) {
			this.gcd = gcd;
			this.x = x;
			this.y = y;
		}
	}

	public static Triplet ExtendedEuclideanAlgo(long a, long b) {
		if (a == 0) {
			return new Triplet(b, 0, 1);
		}
		Triplet ans = ExtendedEuclideanAlgo(b % a, a);
		long x = ans.y - (b / a) * ans.x;
		long y = ans.x;
		return new Triplet(ans.gcd, x, y);
	}

	public static long ModInverse(long a, long m) {
		Triplet ans = ExtendedEuclideanAlgo(a, m);
		if (ans.gcd != 1) {
			//System.out.println("Multiplicative inverse doesnot exist");
			return -1;
		} else {
			//m is added to handle negative x
			long result = (ans.x % m + m) % m;
			return result;
		}
	}
	
	public static FastReader s;
	public static PrintWriter out;

	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

		double nextDouble() {
			return Double.parseDouble(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception e) {
				e.printStackTrace();
			}
			return str;
		}
	}

	
}
