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.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer; 
						  
						
						public class temp4 {
							static class FastReader 
						    { 
						        BufferedReader br; 
						        StringTokenizer st; 
						  
						        public FastReader() 
						        { 
						            br = new BufferedReader(new
						                     InputStreamReader(System.in)); 
						        } 
						  
						        String next() 
						        { 
						            while (st == null || !st.hasMoreElements()) 
						            { 
						                try
						                { 
						                    st = new StringTokenizer(br.readLine()); 
						                } 
						                catch (IOException  e) 
						                { 
						                    e.printStackTrace(); 
						                } 
						            } 
						            return st.nextToken(); 
						        } 
						  
						        int nextInt() 
						        { 
						            return Integer.parseInt(next()); 
						        } 
						  
						        long nextLong() 
						        { 
						            return Long.parseLong(next()); 
						        } 
						  
						        double nextDouble() 
						        { 
						            return Double.parseDouble(next()); 
						        } 
						  
						        String nextLine() 
						        { 
						            String str = ""; 
						            try
						            { 
						                str = br.readLine(); 
						            } 
						            catch (IOException e) 
						            { 
						                e.printStackTrace(); 
						            } 
						            return str; 
						        } 
						    } 
							
						/*	static class Reader 
						    { 
						        final private int BUFFER_SIZE = 1 << 16; 
						        private DataInputStream din; 
						        private byte[] buffer; 
						        private int bufferPointer, bytesRead; 
						  
						        public Reader() 
						        { 
						            din = new DataInputStream(System.in); 
						            buffer = new byte[BUFFER_SIZE]; 
						            bufferPointer = bytesRead = 0; 
						        } 
						  
						        public Reader(String file_name) throws IOException 
						        { 
						            din = new DataInputStream(new FileInputStream(file_name)); 
						            buffer = new byte[BUFFER_SIZE]; 
						            bufferPointer = bytesRead = 0; 
						        } 
						  
						        public String readLine() throws IOException 
						        { 
						            byte[] buf = new byte[64]; // line length 
						            int cnt = 0, c; 
						            while ((c = read()) != -1) 
						            { 
						                if (c == '\n') 
						                    break; 
						                buf[cnt++] = (byte) c; 
						            } 
						            return new String(buf, 0, cnt); 
						        } 
						  
						        public int nextInt() throws IOException 
						        { 
						            int ret = 0; 
						            byte c = read(); 
						            while (c <= ' ') 
						                c = read(); 
						            boolean neg = (c == '-'); 
						            if (neg) 
						                c = read(); 
						            do
						            { 
						                ret = ret * 10 + c - '0'; 
						            }  while ((c = read()) >= '0' && c <= '9'); 
						  
						            if (neg) 
						                return -ret; 
						            return ret; 
						        } 
						  
						        public long nextLong() throws IOException 
						        { 
						            long ret = 0; 
						            byte c = read(); 
						            while (c <= ' ') 
						                c = read(); 
						            boolean neg = (c == '-'); 
						            if (neg) 
						                c = read(); 
						            do { 
						                ret = ret * 10 + c - '0'; 
						            } 
						            while ((c = read()) >= '0' && c <= '9'); 
						            if (neg) 
						                return -ret; 
						            return ret; 
						        } 
						  
						        public double nextDouble() throws IOException 
						        { 
						            double ret = 0, div = 1; 
						            byte c = read(); 
						            while (c <= ' ') 
						                c = read(); 
						            boolean neg = (c == '-'); 
						            if (neg) 
						                c = read(); 
						  
						            do { 
						                ret = ret * 10 + c - '0'; 
						            } 
						            while ((c = read()) >= '0' && c <= '9'); 
						  
						            if (c == '.') 
						            { 
						                while ((c = read()) >= '0' && c <= '9') 
						                { 
						                    ret += (c - '0') / (div *= 10); 
						                } 
						            } 
						  
						            if (neg) 
						                return -ret; 
						            return ret; 
						        } 
						  
						        private void fillBuffer() throws IOException 
						        { 
						            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
						            if (bytesRead == -1) 
						                buffer[0] = -1; 
						        } 
						  
						        private byte read() throws IOException 
						        { 
						            if (bufferPointer == bytesRead) 
						                fillBuffer(); 
						            return buffer[bufferPointer++]; 
						        } 
						  
						        public void close() throws IOException 
						        { 
						            if (din == null) 
						                return; 
						            din.close(); 
						        } 
						    } */
							static class Print
						{
							    private final BufferedWriter bw;
							    public Print()
							    {
							        bw=new BufferedWriter(new OutputStreamWriter(System.out));
							    }
						    public void print(String str)throws IOException
							    {
							        bw.append(str);
							    }
							    public void println(String str)throws IOException
							    {
							        print(str);
							        bw.append("\n");
							    }
							    public void close()throws IOException
							    {
							        bw.close();
							    }} 
								
								
								
								public static void main(String[] args) throws IOException {			
									FastReader scn=new FastReader();
									Print pr=new Print();
									String a=scn.next(),b=scn.next();
									int l1=a.length(),l2=b.length(),x=0,ans=0;
									for(int i=0;i<l2;i++){
										x^=(a.charAt(i)-'0')^(b.charAt(i)-'0');
									}
									ans+=(x==0?1:0);
									for(int i=l2;i<l1;i++){
										x^=(a.charAt(i-l2)-'0')^(a.charAt(i)-'0');
										ans+=(x==0?1:0);
									}
									pr.print(ans+"");
								
									pr.close();
								}
								public static class node{
									int a;
									int b;
									public node(int a,int b){
										this.a=a;this.b=b;
									}
								}
								
						}
							