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 os
  import sys
  from io import BytesIO, IOBase
  from types import GeneratorType
  from collections import defaultdict
  BUFSIZE = 8192
  sys.setrecursionlimit(10**5)
  
  def bootstrap(f,stack=[]):
      def fun(*args,**kwargs):
          if stack:
              return f(*args, **kwargs)
          else:
              to = f(*args, **kwargs)
              while True:
                  if type(to) is GeneratorType:
                      stack.append(to)
                      to=next(to)
                  else:
                      stack.pop()
                      if not stack:
                          break
                      to=stack[-1].send(to)
              return to
      return fun
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  # Python3 function to
  # calculate nCr % p
  
  # Python3 program to answer queries
  # of nCr in O(1) time.
  N = 100001
  
  # array to store inverse of 1 to N
  factorialNumInverse = [None] * (N + 1)
  
  # array to precompute inverse of 1! to N!
  naturalNumInverse = [None] * (N + 1)
  
  # array to store factorial of
  # first N numbers
  fact = [None] * (N + 1)
  
  
  # Function to precompute inverse of numbers
  def InverseofNumber(p):
      naturalNumInverse[0] = naturalNumInverse[1] = 1
      for i in range(2, N + 1, 1):
          naturalNumInverse[i] = (naturalNumInverse[p % i] *
                                  (p - int(p / i)) % p)
  
  
  # Function to precompute inverse
  # of factorials
  def InverseofFactorial(p):
      factorialNumInverse[0] = factorialNumInverse[1] = 1
  
      # precompute inverse of natural numbers
      for i in range(2, N + 1, 1):
          factorialNumInverse[i] = (naturalNumInverse[i] *
                                    factorialNumInverse[i - 1]) % p
  
  
  # Function to calculate factorial of 1 to N
  def factorial(p):
      fact[0] = 1
  
      # precompute factorials
      for i in range(1, N + 1):
          fact[i] = (fact[i - 1] * i) % p
  
  
  # Function to return nCr % p in O(1) time
  def Binomial(N, R, p):
      # n C r = n!*inverse(r!)*inverse((n-r)!)
      ans = ((fact[N] * factorialNumInverse[R]) % p *
             factorialNumInverse[N - R]) % p
      return ans%p
  
  
  
  
  
  
  
  
  p=998244353
  InverseofNumber(p)
  InverseofFactorial(p)
  factorial(p)
  t=1
  for _ in range(t):
      #n=int(input())
      n,k=map(int,input().split())
      s=input()
      b=[]
      pre = [0]
      for j in s:
          b.append(int(j))
          pre.append(pre[-1]+b[-1])
  
      ans=1
      if(k>0 and k<=pre[-1]):
          for i in range(n):
              j=i-1
  
              o=0
              z=0
              if(b[i]):
                  o=1
              else:
                  z=1
  
              while(j>=0):
  
                  if((pre[i+1]-pre[j])>k):
                      j+=1
                      break
                  else:
                      if(b[j]):
                          o+=1
                      else:
                          z+=1
                      j+=-1
              if(j==-1):
                  j=0
              if(z>=1 and o>=1):
                  if(b[i]):
                      z-=1
                  else:
                      o-=1
                  ans=(ans+(Binomial(z+o,z,p)))%p
  
      print(ans)
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  