N people are arranged in a row from left to right.

You are given a string S of length N consisting of `0` and `1`, and a positive integer K.

The i-th person from the left is standing on feet if the i-th character of S is `0`, and standing on hands if that character is `1`.

You will give the following direction at most K times (possibly zero):

Direction: Choose integers l and r satisfying 1 \leq l \leq r \leq N, and flip the l-th, (l+1)-th, ..., and r-th persons. That is, for each i = l, l+1, ..., r, the i-th person from the left now stands on hands if he/she was standing on feet, and stands on feet if he/she was standing on hands.

Find the maximum possible number of consecutive people standing on hands after at most K directions.

Constraints

* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* The length of the string S is N.
* Each character of the string S is `0` or `1`.

Input

Input is given from Standard Input in the following format:


N K
S


Output

Print the maximum possible number of consecutive people standing on hands after at most K directions.

Examples

Input

5 1
00010


Output

4


Input

14 2
11101010110011


Output

8


Input

1 1
1


Output

1
import java.io.InputStream;
import java.io.PrintStream;
import java.util.*;

public class Main {

  public static void main(String[] args) {
    solve(System.in, System.out);
  }

  static void solve(InputStream is, PrintStream os) {
    Scanner sc = new Scanner(is);

    /* read */
    int n = sc.nextInt();
    int k = sc.nextInt();
    String s = sc.next();

    boolean[] sbool = new boolean[n];
    for (int i = 0; i < n; i++) {
      sbool[i] = s.charAt(i) == '1';
    }

    /* logic */
    List<Block> blocks = partitioning(sbool);
    int longest = searchCandidate(blocks, k);
    os.println(longest);
  }

  private static List<Block> partitioning(boolean[] sbool) {

    List<Block> blocks = new ArrayList<>();

    int right = 0;
    for (int left = 0; left < sbool.length; left++) {

      while (right < sbool.length && (sbool[left] == sbool[right])) {
        right++;
      }

      // found the block. if the longest block, let's save
      if (blocks.isEmpty() || ((blocks.get(blocks.size() - 1).end) != right)) {
        Block block = new Block();
        block.start = left;
        block.end = right;
        block.handstanding = sbool[left];
        blocks.add(block);
      }

      // prepare next
      if (left == right) {
        right++;
      }
    }
    return blocks;
  }

  private static int searchCandidate(List<Block> blocks, int remaining) {

    int longest = 0;
    // search the every reversed result starting i-indexed block
    for (int i = 0; i < blocks.size(); i++) {
      Block start = blocks.get(i);

      int mergingBlocks = start.handstanding ? 2 * remaining : 2 * remaining - 1;
      int endIndex = Math.min(Math.max(mergingBlocks, 0) + i, blocks.size() - 1);
      Block end = blocks.get(endIndex);

      int length = end.end - start.start;

      if (length > longest) {
        longest = length;
      }
    }

    return longest;
  }


  private static class Block {

    boolean handstanding;

    // half-open interval
    int start;
    int end;

    @Override
    public String toString() {
      return "Block{" +
          "handstanding=" + handstanding +
          ", start=" + start +
          ", end=" + end +
          '}';
    }
  }

}