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.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.zip.Inflater;

public class Main {
    private static AWriter writer = new AWriter(System.out);
    private static AReader reader = new AReader(System.in);
    private static final int INF=0X3F3F3F3F;
    private static int MAXN=6000+5;
    private static int MAXM=4000+5;
    private static int m,n,N,s,t;
    private static int[] dis;
    private static int[] head;
    private static boolean[] vis;
    private static int[] lev;
    private static int tot;
    private static Edge[][] edges;
    static class Edge{
        int flow,cap;
        public Edge() {
            this.flow = 0;
            this.cap = 0;
        }
    }
    private static int dfs(int s,int t,int flow){
        if(s==t)
            return flow;
        int now=flow;
        for(int i=0;i<N;i++){
            if(lev[i]==lev[s]+1&&edges[s][i].cap>edges[s][i].flow){
                int min=Math.min(now,edges[s][i].cap-edges[s][i].flow);
                int nowFlow=dfs(i,t,min);
                edges[s][i].flow+=nowFlow;
                edges[i][s].flow-=nowFlow;
                now-=nowFlow;
            }
            if(now==0)
                break;
        }
        return flow-now;
    }
    private static boolean bfs(int s,int t){
        lev=new int[MAXN];
        Queue<Integer> queue=new LinkedBlockingQueue<>();
        queue.add(s);
        lev[s]=1;
        while(!queue.isEmpty()){
            int u=queue.poll();
            for(int i=0;i<N;i++){
                if(lev[i]==0&&edges[u][i].cap>edges[u][i].flow){
                    lev[i]=lev[u]+1;
                    queue.add(i);
                }
            }
        }
        return lev[t]!=0;
    }
    private static void dinic(int s,int t){
        int flow=0,tf=0;
        while(bfs(s,t)){
            while((tf=dfs(s,t,INF))!=0){
                flow+=tf;
            }
        }
    }
    private static char[] a,b;
    private static int k;
    public static void main(String[] args) throws IOException {
        a=reader.next().toCharArray();
        b=reader.next().toCharArray();
        int cnt=0,cnt2=0,ans=0;
        for(int i=0;i<b.length;i++) {
            cnt+=b[i]=='1'?1:0;
            cnt2+=a[i]=='1'?1:0;
        }
        if(cnt%2==cnt2%2)
            ans++;
        for(int i=0;i<a.length-b.length;i++) {
            cnt2+=a[i+b.length]=='1'?1:0;
            cnt2-=a[i]=='1'?1:0;
            if(cnt%2==cnt2%2)
                ans++;
        }
        writer.println(ans);
        writer.close();
        reader.close();
    }
}

class AReader implements Closeable {
    private BufferedReader reader;
    private StringTokenizer tokenizer;
    public AReader(InputStream inputStream) {
        reader = new BufferedReader(new InputStreamReader(inputStream));
        tokenizer = new StringTokenizer("");
    }
    private String innerNextLine() {
        try {
            return reader.readLine();
        } catch (IOException ex) {
            return null;
        }
    }
    public boolean hasNext() {
        while (!tokenizer.hasMoreTokens()) {
            String nextLine = innerNextLine();
            if (nextLine == null) {
                return false;
            }
            tokenizer = new StringTokenizer(nextLine);
        }
        return true;
    }
    public String nextLine() {
        tokenizer = new StringTokenizer("");
        return innerNextLine();
    }
    public String next() {
        hasNext();
        return tokenizer.nextToken();
    }
    public int nextInt() {
        return Integer.valueOf(next());
    }
    public long nextLong() {
        return Long.valueOf(next());
    }
    public double nextDouble() {
        return Double.valueOf(next());
    }
    public BigDecimal nextBigDecimal(){ return new BigDecimal(next()); }
    public BigInteger nextBigInteger() {
        return new BigInteger(next());
    }
    @Override
    public void close() throws IOException {
        reader.close();
    }
}

// Fast writer for ACM By Azure99
class AWriter implements Closeable {
    private BufferedWriter writer;

    public AWriter(OutputStream outputStream) {
        writer = new BufferedWriter(new OutputStreamWriter(outputStream));
    }

    public void print(Object object) throws IOException {
        writer.write(object.toString());
    }

    public void println(Object object) throws IOException {
        writer.write(object.toString());
        writer.write("\n");
    }

    @Override
    public void close() throws IOException {
        writer.close();
    }
}

class model{
//    private static void dijkstra(int start){
//        PriorityQueue<Main.Node> queue=new PriorityQueue<>();
//        queue.add(new Main.Node(start,0));
//        dis[start][0]=0;
//        while(!queue.isEmpty()){
//            Main.Node node=queue.poll();
//            int law=node.mes/n;
//            int u=node.mes%n;
//            if(vis[u][law])
//                continue;
//            vis[u][law]=true;
//            for(int i=head[u];i!=-1;i=edges[i].next){
//                int v = edges[i].to;
//                if (dis[v][law] > dis[u][law] + edges[i].w) {
//                    dis[v][law] = dis[u][law] + edges[i].w;
//                    queue.add(new Main.Node(v+law*n,dis[v][law]));
//                }
//                if(law<k&&dis[v][law+1]>dis[u][law]){
//                    dis[v][law+1] = dis[u][law];
//                    queue.add(new Main.Node(v+(law+1)*n,dis[v][law+1]));
//                }
//            }
//        }
//    }
}