The unlucky Ikta-kun has rewritten the important character string T that he had to a different character string T'by the virus. It is known that the virus has rewritten one letter of T to a different letter. That is, T and T'are different by exactly one character. In order to restore T, Ikta prepared a document S in which T appears. As a preparation for restoring T, I would like to find out the number of substrings of S that may match T.

Given the string T'and the document S. S = a1 a2 a3 .. .a | S | length | T'| substring ak ak + 1 ... ak + | T'| −1 (1 ≤ k ≤ | S | − | T'| Find the number of things that differ by one character from T'in +1).



Input

The input is given in the following format.


S
T'


* S is given in the first line.
* T'is given in the second line.
* S and T'consist only of uppercase and lowercase alphabets, respectively.



Constraints

Each variable being input satisfies the following constraints.

* 1 ≤ | S | ≤ 300,000
* 1 ≤ | T'| ≤ | S |

Output

Output the number of substrings that satisfy the conditions on one line.

Examples

Input

abcbcdbc
abc


Output

2


Input

aaaaaa
aaaaaa


Output

0


Input

baaaaaaaa
b


Output

8
#include <bits/stdc++.h>
using namespace std;
#define all(x)   (x).begin(),(x).end()
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define isYES(x) printf("%s\n",(x) ? "YES" : "NO")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define isYes(x) printf("%s\n",(x) ? "Yes" : "No")
#define isIn(x,y,h,w) (x >= 0 && x < h && y >= 0 && y < w)

#define int long long
//using ll = long long;
using P = pair<int,int>;

ostream &operator<<(ostream &os,const P &p){ return os << "(" << p.first << "," << p.second << ")"; }

template<class T> T &chmin(T &a,const T &b){ return a = min(a,b); }
template<class T> T &chmax(T &a,const T &b){ return a = max(a,b); }
 
const int INF=1e+18;
const double EPS=1e-9;
const int MOD=1000000007;

const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};

const long long bases[] = {10007,10009/*,10037*/};

template<long long mod = 1000000007>
struct RollingHashSimple{
	using ll = long long;
	vector<ll> hashes[2],powers[2];
	RollingHashSimple(const string &s){
		int n = s.length();
		for(int i = 0;i < 2;i++){
			hashes[i].resize(n + 1,0);
			powers[i].resize(n + 1,1);
			for(int j = 0;j < n;j++){
				powers[i][j + 1] = powers[i][j] * bases[i] % mod;
				hashes[i][j + 1] = (hashes[i][j] * bases[i] + s[j]) % mod;
			}
		}
	}
	inline ll hash(int l,int r,int b) const{
		return (hashes[b][r] - hashes[b][l] * powers[b][r - l] % mod + mod) % mod;
	}
	ll hash(int l = 0,int r = -1) const{
		if(r == -1) r = hashes[0].size() - 1;
		return hash(l,r,0) * mod + hash(l,r,1);
	}
	inline bool isSame(int a,int b,int c,int d) const{
		return hash(a,b) == hash(c,d);
	}
};

signed main(){
	string s,t;
	cin >> s >> t;
	RollingHashSimple<> rhs(s),rht(t);
	vector<int> st;
	for(int i = 0;i < t.length();i++){
		for(int j = 'A';j <= 'z';j++){
			if(!isalpha(j) || j == t[i]) continue;
			int hash[2];
			for(int k = 0;k < 2;k++){
				hash[k] = (rht.hash(0,t.length(),k) + (j - t[i] + MOD) * rht.powers[k][t.length() - i - 1]) % MOD;
			}
			st.push_back(hash[0] * MOD + hash[1]);
		}
	}
	sort(all(st));
	int ans = 0;
	for(int i = 0;i < s.length() - t.length() + 1;i++){
		int x = rhs.hash(i,i + t.length());
		int ind = lower_bound(all(st),x) - st.begin();
		if(ind < st.size() && st[ind] == x) ans++;
	}
	cout << ans << endl;
}
