One of Arkady's friends works at a huge radio telescope. A few decades ago the telescope has sent a signal $s$ towards a faraway galaxy. Recently they've received a response $t$ which they believe to be a response from aliens! The scientists now want to check if the signal $t$ is similar to $s$.

The original signal $s$ was a sequence of zeros and ones (everyone knows that binary code is the universe-wide language). The returned signal $t$, however, does not look as easy as $s$, but the scientists don't give up! They represented $t$ as a sequence of English letters and say that $t$ is similar to $s$ if you can replace all zeros in $s$ with some string $r_0$ and all ones in $s$ with some other string $r_1$ and obtain $t$. The strings $r_0$ and $r_1$ must be different and non-empty.

Please help Arkady's friend and find the number of possible replacements for zeros and ones (the number of pairs of strings $r_0$ and $r_1$) that transform $s$ to $t$.


-----Input-----

The first line contains a string $s$ ($2 \le |s| \le 10^5$) consisting of zeros and ones — the original signal.

The second line contains a string $t$ ($1 \le |t| \le 10^6$) consisting of lowercase English letters only — the received signal.

It is guaranteed, that the string $s$ contains at least one '0' and at least one '1'.


-----Output-----

Print a single integer — the number of pairs of strings $r_0$ and $r_1$ that transform $s$ to $t$.

In case there are no such pairs, print $0$.


-----Examples-----
Input
01
aaaaaa

Output
4

Input
001
kokokokotlin

Output
2



-----Note-----

In the first example, the possible pairs $(r_0, r_1)$ are as follows:  "a", "aaaaa"  "aa", "aaaa"  "aaaa", "aa"  "aaaaa", "a"  

The pair "aaa", "aaa" is not allowed, since $r_0$ and $r_1$ must be different.

In the second example, the following pairs are possible:   "ko", "kokotlin"  "koko", "tlin"

Difficulty: interview

Starter code:

Solutions:
import sys
from math import *

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())

def add(a,b):
	return (a+b)%1000000007

def sub(a,b):
	return (a+1000000007-b)%1000000007

def mul(a,b):
	return (a*b)%1000000007

p = 102367
s = list(map(int,minp()))
t = list(map(ord,minp()))
h = [0]*(len(t)+1)
pp = [1]*(len(t)+1)
for i in range(len(t)):
	h[i+1] = add(mul(h[i], p), t[i])
	pp[i+1] = mul(pp[i], p)

def cmp(a, b, l):
	if a > b:
		a, b = b, a
	h1 = sub(h[a+l], mul(h[a], pp[l]))
	h2 = sub(h[b+l], mul(h[b], pp[l]))
	return h2 == h1

c = [0,0]
idx = [-1,-1]
for i in range(len(s)):
	c[s[i]] += 1
	if idx[s[i]] < 0:
		idx[s[i]] = i
Mv = max(c)
mv = min(c)
Mi = c.index(Mv)
mi = (Mi^1)
lt = len(t)
sp = [0,0]
res = 0
for k in range(1,lt//Mv+1):
	l = [0,0]
	x = (lt-k*Mv)//mv
	if x > 0 and x*mv + k*Mv == lt:
		l[Mi] = k
		l[mi] = x
		if idx[0] < idx[1]:
			sp[0] = 0
			sp[1] = idx[1]*l[0]
		else:
			sp[1] = 0
			sp[0] = idx[0]*l[1]
		ok = True
		j = 0
		for i in range(len(s)):
			if not cmp(sp[s[i]], j, l[s[i]]):
				ok = False
				break
			j += l[s[i]]
		if l[0] == l[1] and cmp(sp[0], sp[1], l[0]):
			ok = False
		if ok:
			res += 1
print(res)

def gethash(l,r):
	return (ha[r]-((ha[l]*p[r-l])%mod)+mod)%mod

def check(lenx,leny):
	ha_0=-1
	ha_1=-1
	j=0
	for i in range(m):
		if s[i]=="0":
			tmp=gethash(j,j+lenx)
			if ha_0==-1:
				ha_0=tmp
			elif ha_0!=tmp:
				return 0
			j+=lenx
		else:
			tmp=gethash(j,j+leny)
			if ha_1==-1:
				ha_1=tmp
			elif ha_1!=tmp:
				return 0
			j+=leny
	return ha_0!=ha_1
	
s=list(input())
t=list(input())
m=len(s)
n=len(t)

p=[1]
bas=2333
mod=(1<<50)-2
for i in range(1,n+1):
	p.append((p[i-1]*bas)%mod)
ha=[0]
for i in range(1,n+1):
	ha.append((ha[i-1]*bas+ord(t[i-1]))%mod)
cnt_0=0
cnt_1=0
for x in s:
	if x=="0":
		cnt_0+=1
	else:
		cnt_1+=1

ans=0
for i in range(1,n//cnt_0+1):#length of r_0
	j=n-cnt_0*i
	if j%cnt_1==0 and j!=0:
		j//=cnt_1
		ans+=check(i,j)
print(ans)

s = input()
t = input()

n,m = len(s), len(t)
a = s.count('0')
b = len(s) - a


pow = [1] * m
h = [0] * (m+1)
p, mod = 31, 10**9+9
for i in range(1, m):
    pow[i] = pow[i-1] * p % mod

for i in range(m):
    h[i+1] = (h[i] + (ord(t[i])-ord('a')+1) * pow[i]) % mod


def get_hash(i, j):
    hash_value = (h[j] - h[i] + mod) % mod
    hash_value = (hash_value * pow[m-i-1]) % mod
    return hash_value


def check(x, y):
    index = 0
    hash_x = hash_y = -1
    for i in range(n):
        if s[i] == '0':
            if hash_x == -1:
                hash_x = get_hash(index, index+x)
            else:
                if get_hash(index, index+x) != hash_x: return False
            index += x
        else:
            if hash_y == -1:
                hash_y = get_hash(index, index+y)
            else:
                if get_hash(index, index+y) != hash_y: return False
            index += y
    return hash_x != hash_y


res = 0
for x in range(1, m//a+1):
    if (m - a*x) % b == 0:
        y = (m - a*x) // b
        if y == 0: continue
        if check(x ,y):
            res += 1

print(res)