You are given a binary string (i. e. a string consisting of characters 0 and/or 1) s of length n. You can perform the following operation with the string s at most once: choose a substring (a contiguous subsequence) of s having exactly k characters 1 in it, and shuffle it (reorder the characters in the substring as you wish).

Calculate the number of different strings which can be obtained from s by performing this operation at most once.

Input

The first line contains two integers n and k (2 ≤ n ≤ 5000; 0 ≤ k ≤ n).

The second line contains the string s of length n, consisting of characters 0 and/or 1.

Output

Print one integer — the number of different strings which can be obtained from s by performing the described operation at most once. Since the answer can be large, output it modulo 998244353.

Examples

Input


7 2
1100110


Output


16


Input


5 0
10010


Output


1


Input


8 1
10001000


Output


10


Input


10 8
0010011000


Output


1

Note

Some strings you can obtain in the first example:

  * to obtain 0110110, you can take the substring from the 1-st character to the 4-th character, which is 1100, and reorder its characters to get 0110; 
  * to obtain 1111000, you can take the substring from the 3-rd character to the 7-th character, which is 00110, and reorder its characters to get 11000; 
  * to obtain 1100101, you can take the substring from the 5-th character to the 7-th character, which is 110, and reorder its characters to get 101. 



In the second example, k = 0 so you can only choose the substrings consisting only of 0 characters. Reordering them doesn't change the string at all, so the only string you can obtain is 10010.
5 2
00011
 5 4
11011
 81 5
100000101000000011001101010100001010111000000110000000001000101101111000001000110
 4 3
1011
 47 25
11110011111001110100101010011000110111011011101
 291 159
011001110111110110001111000110001001111100010001011000110100110010001101100110111010101111100111110000110111001100111010001000011001010011011100101000101011010110010011010100100101111010111000001011110101001011101110100100111110011001101010001110110101010101100011101110111000011111011001110
 459 15
101010101010101010101010101010101010101010101111111111111111111111010101010101010101010101011111111111111111111101010101010101010101111111111111111111111101010101010101010111111111111111111111111101010101010101111111111111111111111111110110101010101011111111111111111111111111111001000111111111111111111111111111110000011111111111111111111111111111000001111111111111111111111111111100001111111111111111111111111111100111111111111111111111111111110111111111111
 105 58
110101000111100000011011011101110100001000110011010101100010111001011111010010111101011011010110011011110
 52 11
0110011111001000010000100010010001010100000100110100

10
 5
 187538
 4
 314445058
 1
 0
 132732930
 478323746

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.*;

//import sun.nio.fs.RegistryFileTypeDetector;


 
public class Codeforces {
	static int mod= 998244353;
	
	public static void main(String[] args) throws Exception {
		PrintWriter out=new PrintWriter(System.out);
		FastScanner fs=new FastScanner();
		int t=1;
		
		outer:while(t-->0) {
			int n=fs.nextInt(), k=fs.nextInt();
			char s[]=fs.next().toCharArray();
			int cnt=0;
			for(char c:s) if(c=='1') cnt++;
			if(cnt<k) {
				out.println(1);
				continue;
			}
			long ans= find(s,n,k);
			int ind=n-1;
			while(ind>=0&&s[ind]=='0') ind--;
			int j=0;
			while(j<ind&&s[ind]=='0') j++;
			
			if(ind>0&&ind-j-1>0) {
				char brr[]=new char[ind-j-1];
				for(int i=j+1;i<ind;i++) brr[i-j-1]=s[i];
				ans-=find(brr,ind-j-1,k-1);
				ans%=mod;
				if(ans<0) ans+=mod;
//				for(char c:brr) System.out.print(c);
//				System.out.println();
			}
			out.println(ans);
		}
		
		out.close();
		
	}
	static long find(char s[],int n,int k) {
		if(k<0) return 0;
		List<Integer> left=new ArrayList<>(), right=new ArrayList<>();
		int cnt=0;
		int l=0;
		int	r=0;
		while(r<n) {
			while(cnt<k&&r<n) {
				if(s[r]=='1') cnt++;
				r++;
			}
			while(r<n&&s[r]=='0') r++;
//		if(r==in) r++;
//			System.out.println(cnt);
			if(cnt==k) {
				left.add(l); right.add(r-1);
			}
			while(l<n&&s[l]=='0') l++;
			l++;
		 	cnt--;

		 }
		
		long ans=0;
		
		int z[]=new int[n+1];
		int o[]=new int[n+1];
		for(int i=1;i<=n;i++) {
			if(s[i-1]=='0') {
				z[i]=z[i-1]+1;
				o[i]=o[i-1];
			}
			else {
				z[i]=z[i-1];
				o[i]=o[i-1]+1;
			}
			
		}
//		for(int i=0;i<left.size();i++) {
//			System.out.println(left.get(i)+" "+right.get(i));
//		}
		if(left.size()==0||k==0) {
			return 1;
			
		}
		for(int i=0;i<left.size();i++) {
			r=right.get(i);
			l=left.get(i);
			int cnto= o[r+1]-o[l];
			int cntz= z[r+1]-z[l];
			ans+= nck(cnto+cntz, cnto);
			ans%=mod;
			
		}
		return ans;
	}
	static long pow(long a,long b) {
		if(b<0) return 1;
		long res=1;
		while(b!=0) {
			if((b&1)!=0) {
				res*=a;
				res%=mod;
			}
			a*=a;
			a%=mod;
			b=b>>1;
		}
		return res;
	}
	static int gcd(int  a,int  b) {
		if(b==0) return a;
		return gcd(b,a%b);
	}
	static long nck(int n,int k) {
		if(k>n) return 0;
		long res=1;
		res*=fact(n);
		res%=mod;
		res*=modInv(fact(k));
		res%=mod;
		res*=modInv(fact(n-k)); 
		res%=mod;
		return res;
	}
	static long fact(long n) {
//		return fact[(int)n];
		long res=1;
		for(int i=2;i<=n;i++) {
			res*=i;
			res%=mod;
		}
		return res;
	}
	
	static long modInv(long n) {
		return pow(n,mod-2);
	}
	
	static void sort(int[] a) {
		//suffle
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			int oi=r.nextInt(n);
			int temp=a[i];
			a[i]=a[oi];
			a[oi]=temp;
		}
		
		//then sort
		Arrays.sort(a);
	}
	
	// Use this to input code since it is faster than a Scanner
	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}
		
		int nextInt() {
			return Integer.parseInt(next());
		}
		long[] lreadArray(int n) {
			long a[]=new long[n];
			for(int i=0;i<n;i++) a[i]=nextLong();
			return a;
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}
 
}