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"

Source: codeforces | Difficulty: HARD
Tags: String algorithms

Data structures

Complete search


Solutions:
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):
	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)
			elif get_hash(index, index + x) != hash_x:
				return False
			index += x
		else:
			if hash_y == -1:
				hash_y = get_hash(index, index + y)
			elif 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)


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)