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: Runtime Error)

#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
#include <fstream>
#define popcount __builtin_popcount
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
const ll MOD=1e9+7;
int n;
bool used[500001];
int cmp[500001];
vector<int> g[500001], gr[500001];
vector<int> vs;

void dfs(int x){
	used[x]=1;
	for(auto y:g[x]){
		if(!used[y]) dfs(y);
	}
	vs.push_back(x);
}
 
void rdfs(int v, int k){
	used[v]=1;
	cmp[v]=k;
	for(auto y:gr[v]){
		if(!used[y]) rdfs(y, k);
	}
}
int scc(){
	fill(used, used+n, 0);
	vs.clear();
	for(int i=0; i<n; i++){
		if(!used[i]) dfs(i);
	}
	fill(used, used+n, 0);
	int k=0;
	for(int i=vs.size()-1; i>=0; i--){
		if(!used[vs[i]]) rdfs(vs[i], k++);
	}
	return k;
}
int dp[500010];
int solve(int x){
    if(dp[x]>=0) return dp[x];
    int ret=0;
    for(auto y:g[x]){
        ret=max(ret, solve(y)+1);
    }
    return dp[x]=ret;
}
int main()
{
    string s, t; cin>>s>>t;
    n=s.size();
  int m=t.size();
    string s0=s;
    while(s0.size()<t.size()+s.size()) s0+=s;
    ll bs[2000020];
    bs[0]=0;
    ll b=67;
    ll bp=1;
    for(int i=0; i<s0.size(); i++){
        bs[i+1]=(bs[i]+bp*s0[i])%MOD;
        bp=bp*b%MOD;
    }
    bp=1;
    ll bt=0;
    for(int i=0; i<m; i++){
        (bt+=bp*t[i])%=MOD;
        bp=bp*b%MOD;
    }
    bp=1;
    int nx[500010];
    for(int i=0; i<n; i++){
        if((bs[i+m]-bs[i]+MOD)%MOD==bt*bp%MOD){
            g[i].push_back((i+m)%n);
            gr[(i+m)%n].push_back(i);
          //cout<<i<<" "<<(i+m)%n<<endl;
        }
        bp=bp*b%MOD;
    }
    int k=scc();
    if(k<n){
        cout<<-1<<endl;
        return 0;
    }
    fill(dp, dp+n, -1);
    int ans=0;
    for(int i=0; i<n; i++){
        ans=max(ans, solve(i));
    }
    cout<<ans<<endl;
    return 0;
}