Problem:
Score : 600 points

Problem Statement

Given are two strings s and t consisting of lowercase English letters. Determine if the number of non-negative integers i satisfying the following condition is finite, and find the maximum value of such i if the number is finite.

There exists a non-negative integer j such that the concatenation of i copies of t is a substring of the concatenation of j copies of s.

Notes

A string a is a substring of another string b if and only if there exists an integer x (0 \leq x \leq |b| - |a|) such that, for any y (1 \leq y \leq |a|), a_y = b_{x+y} holds.

We assume that the concatenation of zero copies of any string is the empty string. From the definition above, the empty string is a substring of any string. Thus, for any two strings s and t, i = 0 satisfies the condition in the problem statement.

Constraints

1 \leq |s| \leq 5 \times 10^5

1 \leq |t| \leq 5 \times 10^5

s and t consist of lowercase English letters.

Input

Input is given from Standard Input in the following format:

s
t

Output

If the number of non-negative integers i satisfying the following condition is finite, print the maximum value of such i; if the number is infinite, print -1.

Sample Input 1

abcabab
ab

Sample Output 1

3

The concatenation of three copies of t, ababab, is a substring of the concatenation of two copies of s, abcabababcabab, so i = 3 satisfies the condition.

On the other hand, the concatenation of four copies of t, abababab, is not a substring of the concatenation of any number of copies of s, so i = 4 does not satisfy the condition.

Similarly, any integer greater than 4 does not satisfy the condition, either. Thus, the number of non-negative integers i satisfying the condition is finite, and the maximum value of such i is 3.

Sample Input 2

aa
aaaaaaa

Sample Output 2

-1

For any non-negative integer i, the concatenation of i copies of t is a substring of the concatenation of 4i copies of s. Thus, there are infinitely many non-negative integers i that satisfy the condition.

Sample Input 3

aba
baaab

Sample Output 3

0

As stated in Notes, i = 0 always satisfies the condition.

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;

vector<int> make(const string& str){
	int n=str.size();
	vector<int> ret(n+1);
	ret[0]=-1;
	int j=-1;
	for(int i=0;i<n;i++){
		while(j>=0 && str[i]!=str[j]){
			j=ret[j];
		}
		ret[i+1]=++j;
	}
	return ret;
}

vector<int> kmp(const string& str,const string& word){
	vector<int> table=make(word),ret;
	int m=0,i=0,n=str.size();
	while(m+i<n){
		if(word[i]==str[m+i]){
			if(++i==(int)(word.size())){
				ret.push_back(m);
				m=m+i-table[i];
				i=table[i];
			}
		}else{
			m=m+i-table[i];
			if(i>0)i=table[i];
		}
	}
	return ret;
}

struct graph_scc{
	int V;
	static const int MAX=2000005;
	vector<int> G[MAX];
	vector<int> rG[MAX];
	vector<int> ci[MAX];
	vector<int> vs;
	bool used[MAX];
	int cmp[MAX];
	void init(int n){
		V=n;
		for(int i=0;i<V;i++){
			G[i].clear();
			rG[i].clear();
		}
		vs.clear();
		memset(cmp,0,sizeof(cmp));
	}
	void add_edge(int from,int to){
		G[from].push_back(to);
		rG[to].push_back(from);
	}

	void dfs(int v){
		used[v]=true;
		for(int i=0;i<G[v].size();i++){
			if(!used[G[v][i]])dfs(G[v][i]);
		}
		vs.push_back(v);
	}
	void rdfs(int v,int k){
		used[v]=true;
		cmp[v]=k;
		ci[cmp[v]].push_back(v);
		for(int i=0;i<rG[v].size();i++){
			if(!used[rG[v][i]])rdfs(rG[v][i],k);
		}
	}

	int scc(int n){
		V=n;
		memset(used,0,sizeof(used));
		vs.clear();
		for(int v=0;v<V;v++){
			if(!used[v])dfs(v);
		}
		memset(used,0,sizeof(used));
		int k=0;
		for(int i=vs.size()-1;i>=0;i--){
			if(!used[vs[i]]){
				rdfs(vs[i],k++);
			}
		}
		return k;
	}
};

string s,t;
graph_scc sc;
int maxi[1500005];

int main(void){
	cin >> s;
	cin >> t;
	string ns="";
	while(ns.size()<t.size()+s.size()){
		ns+=s;
	}
	vector<int> edges=kmp(ns,t);

	for(int i=0;i<edges.size();i++){
		sc.add_edge(edges[i],(edges[i]+t.size())%s.size());
	}
	int sz=sc.scc(s.size());
	int ans=0;
	for(int i=sz-1;i>=0;i--){
		if(sc.ci[i].size()>=2){
			printf("%d\n",-1);
			return 0;
		}
		for(int j=0;j<sc.ci[i].size();j++){
			int v=sc.ci[i][j];
			for(int k=0;k<sc.G[v].size();k++){
				int nv=sc.G[v][k];
				if(sc.cmp[v]<sc.cmp[nv]){
					maxi[v]=max(maxi[v],maxi[nv]+1);
					ans=max(maxi[v],ans);
				}
			}
		}
	}
	printf("%d\n",ans);
	return 0;
}