Vus the Cossack has two binary strings, that is, strings that consist only of "0" and "1". We call these strings a and b. It is known that |b| ≤ |a|, that is, the length of b is at most the length of a.

The Cossack considers every substring of length |b| in string a. Let's call this substring c. He matches the corresponding characters in b and c, after which he counts the number of positions where the two strings are different. We call this function f(b, c).

For example, let b = 00110, and c = 11000. In these strings, the first, second, third and fourth positions are different.

Vus the Cossack counts the number of such substrings c such that f(b, c) is even.

For example, let a = 01100010 and b = 00110. a has four substrings of the length |b|: 01100, 11000, 10001, 00010. 

  * f(00110, 01100) = 2;
  * f(00110, 11000) = 4;
  * f(00110, 10001) = 4;
  * f(00110, 00010) = 1.



Since in three substrings, f(b, c) is even, the answer is 3.

Vus can not find the answer for big strings. That is why he is asking you to help him.

Input

The first line contains a binary string a (1 ≤ |a| ≤ 10^6) — the first string.

The second line contains a binary string b (1 ≤ |b| ≤ |a|) — the second string.

Output

Print one number — the answer.

Examples

Input


01100010
00110


Output


3


Input


1010111110
0110


Output


4

Note

The first example is explained in the legend.

In the second example, there are five substrings that satisfy us: 1010, 0101, 1111, 1111.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;

public class C {
	static Random random;
	private static void mySort(int[] s) {
        for (int i = 0; i < s.length; ++i) {
            int j = random.nextInt(i + 1);
            int t = s[i];
            s[i] = s[j];
            s[j] = t;
        }
        Arrays.sort(s);
    }
	
	static class Pair{
		int x;
		int y;
		
		public Pair(int x, int y) {
			this.x=x;
			this.y=y;
		}
	}
	
	public static void sortPairX(Pair[] p) {
		Arrays.sort(p, new Comparator<Pair>() {
			public int compare(Pair o1, Pair o2) {
				return o1.x-o2.x;
			}			
		});
	}
	
	public static void sortPairY(Pair[] p) {
		Arrays.sort(p, new Comparator<Pair>() {
			public int compare(Pair o1, Pair o2) {
				return o1.y-o2.y;
			}			
		});
	}
	
	

	public static void main(String[] args) {
		random = new Random(543534151132L + System.currentTimeMillis());
		InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
       
        String a=in.next();
        String b=in.next();
        int l=b.length();
        int la=a.length();
        
        int count=0;
        int c=0;
        for(int i=0;i<l;i++)if(b.charAt(i)=='1')c++;
        int[] T=new int[la-l+1];
        
        int c1=0;
        for(int i=0;i<l;i++) {
        	if(a.charAt(i)=='1')c1++;
        }
        T[0]=c1;
        
        for(int i=l;i<la;i++) {
        	if(a.charAt(i)=='1' && a.charAt(i-l)=='1')T[i-l+1]=T[i-l];
        	else if(a.charAt(i)=='0' && a.charAt(i-l)=='1')T[i-l+1]=T[i-l]-1;
        	else if(a.charAt(i)=='1' && a.charAt(i-l)=='0')T[i-l+1]=T[i-l]+1;
        	else if(a.charAt(i)=='0' && a.charAt(i-l)=='0')T[i-l+1]=T[i-l];
        }
        
        
        for(int i=0;i<T.length;i++) {
        	if(T[i]%2==c%2)count++; 
        }
        
        out.println(count);
        
        
		out.close();
		
	}
	
	

	public static int gcd(int a, int b)  
    { 
        BigInteger b1 = BigInteger.valueOf(a); 
        BigInteger b2 = BigInteger.valueOf(b); 
        BigInteger gcd = b1.gcd(b2); 
            return gcd.intValue(); 
    } 
      
    public static long gcd(long a, long b)  
    { 
        BigInteger b1 = BigInteger.valueOf(a); 
        BigInteger b2 = BigInteger.valueOf(b); 
        BigInteger gcd = b1.gcd(b2); 
            return gcd.longValue(); 
    } 
	
	static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        
        public long nextLong() {
            return Long.parseLong(next());
        }
        
        public double nextDouble() {
            return Double.parseDouble(next());
        }
        
        public float nextFloat() {
            return Float.parseFloat(next());
        }
        
    }

}