description: 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.
solution: #import io,os
  #input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
  
  M = 998244353
  
  
  MAXNUM = 100000
  factor = [1]*(MAXNUM+2)
  factor[-1]=0
  storecomb = {}
  
  
  for i in range(1,MAXNUM+1):
      factor[i] = (factor[i-1]*i)%M
  
  def fastfrac(a,b):
      numb = pow(b,M-2,M)
      return ((a%M)*(numb%M))%M
  
  def comb(n,k):
  #    print "*",n,k
      if k<0: return 0
      if n<k: return 0
      if n==k: return 1
      if (n,k) in storecomb:  return storecomb[(n,k)]
  
      num1 = factor[n]
      num2 = factor[k]
      num3 = factor[n-k]
      num = (num2*num3)%M
      output = fastfrac(num1,num)
      storecomb[(n,k)] = output
      return output
  
  
  
  
  def main(t):
  
  
      n,k = map(int,input().split())
      s = input()
  
      if k==0:  
          print(1)
          return 
  
      count = 0
      for i in range(n):
          if s[i]=='1': count += 1
  
      if count<k:  
          print(1)
          return 
     
      
  
  
  
  
  
  
      ones = [-1]
  
      ans = 1
      for i in range(n):
  
          if s[i]=='1':
              ones.append(i)
              if len(ones) < k+1:  
                  front = -1 
              else:
                  front = ones[-k-1]
              num = min(k,len(ones)-1)
              ans += comb(i-front-1, num)
          else:
              if len(ones)==1: continue 
              if len(ones) < k+1: 
                  front = -1
              else:
                  front = ones[-k-1]
              num = min(k,len(ones)-1)
  
              ans += comb(i-front-1,num-1)
  
          ans = ans % M
  #        print(i,ans)
  
  
  
  
  
          
          
  
  
  
  
      print(ans%M)
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  T = 1 #int(input())
  t = 1
  while t<=T:
      main(t)
      t += 1
  