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 <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <chrono>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <cassert>
#include <tuple>
#include <iomanip>
#include <random>
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <fstream>
#include <unordered_map>

#define ll long long

using namespace std;

const int MINN = 2001;
const int maxn = (int) 2e7 + 100;
const int inf = 1e9 + 7;

vector < int > g[maxn], give, can;
vector < int > v;
pair < int, int > p[maxn];
ll a[7010];

int u[maxn], b[maxn];

string s, t;

int z[maxn];

int main(){
    cin >> s >> t;
    string q = s;
    while(s.size() < t.size()){
        s += q;
    }
    s += s;
    string st = t + '#' + s;
    int n = (int)st.size();
    int l = 0, r = 0;
    for(int i = 1; i < n; i++){
        if(i <= r){
            z[i] = min(r - i + 1, z[i - 1]);
        }
        while(i + z[i] < n && st[z[i]] == st[z[i] + i])
            z[i]++;
        if(i + z[i] - 1 > r){
            l = i, r = i + z[i] - 1;
        }
    }
    for(int i = t.size() + 1; i < t.size() + 1 + q.size(); i++){
        if(z[i] == t.size()){
            can.push_back(i - t.size() - 1);
            u[i - t.size() - 1] = 1;
            //cout << i - t.size() - 1 << " ";
        }
    }
    if(can.empty()){
        cout << 0;
        return 0;
    }
    for(int i = 0; i < can.size(); i++) {
        if(b[can[i]] == 1){
            continue;
        }
        v.clear();
        int now = can[i];
        b[now] = 1;
        v.push_back(now);
        now += t.size();
        now %= q.size();
        bool qwe = 0;
        while (1) {
            b[now] = 1;
            v.push_back(now);
            now += t.size();
            now %= q.size();
            if (now == can[0]) {
                if (!qwe)
                    qwe = 1;
                else
                    break;
            }
        }
        int cnt = 0, res = 0;
        for (int i = 0; i < v.size(); i++) {
            if (u[v[i]] == 1) {
                cnt++;
                res = max(cnt, res);
            } else {
                cnt = 0;
            }
        }
        if (res == v.size()) {
            cout << -1;
        } else {
            cout << res;
        }
        return 0;
    }
}