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 sys
  input = sys.stdin.readline 
  
  N, K = map(int,input().split())
  
  S = list(input().rstrip())
  S = [int(s) for s in S]
  mod = 998244353
    
  from time import time
  """
  N, K = 10 * 5*10**2, 10 * 3*10**2
  S = ["10110" for i in range(K)]
  S = "".join(S)
  S = [int(s) for s in S]
  """
  it = time()
  
  cons = 0
  prof = []
  for s in S:
    if s == 0:
      cons += 1
    else:
      prof.append(cons)
      cons = 0
      
  prof.append(cons)
  #print(prof)  
  #print("1", time() - it)
  _inv_t = {}
  _inv_t[1] = 1
  _inv_t[0] = 0
  def inv(x, mod):
    x %= mod
    if x not in _inv_t:
      _inv_t[x] = inv(mod % x, mod) * (mod - mod // x) % mod
    return _inv_t[x]
  
  for x in range(2,N+10):
    _inv_t[x] = inv(mod % x, mod) * (mod - mod // x) % mod
  
  comb = [[1, 0], [1, 1, 0]]
  for n in range(2, N+3):
    now = 1
    arr = [1]
    for i in range(1, n + 1):
      arr.append((comb[-1][i-1] + comb[-1][i]) % mod)
    arr.append(0)
    comb.append(arr)
      
  #print(comb)    
  #print("2", time() - it)
  import sys
  if K == 0:
    print(1)
    sys.exit()
  if K > S.count(1):
    print(1)
    sys.exit()
  
    
  ans = 0
  fac = -1
  for k in range(K, max(-1, K-2), -1):
    fac *= -1
    n = sum(prof[K-k:K+1]) + k
    for i in range(K + 1, len(prof)-(K-k)+1):
      #print("n", n)
      ans += comb[n][k] * fac
      ans %= mod
      if i < len(prof):
        n += prof[i]
        n -= prof[i-k-1]
    #print(ans)  
  
  #print("3", time() - it)
    
  print(ans)
    