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: Accepted)

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>

#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>

#include <functional>
#include <cassert>

typedef long long ll;
using namespace std;

#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;

template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
  out << "{" << p.first << ", " << p.second << "}";
  return out;
}

template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
  out << '{';
  for (const T &item : v) out << item << ", ";
  out << "\b\b}";
  return out;
}
#endif

#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 2000010

/* Rolling Hash */
// n = 9973, 10007, 1073741789, 1036870427, 999999733

struct RollingHash{
  int N, base;
  vector<ll> hash, pow;

  template <typename Type>
  RollingHash(int base, int n, Type *arr):
    N(n), base(base), hash(n+1), pow(n+1)
  {
    hash[0] = 0;
    pow[0] = 1;
    for(int i=0; i<N; i++){
      hash[i+1] = (hash[i] + arr[i]) * base % mod;
      pow[i+1] = pow[i] * base % mod;
    }
  }

  // get [l,r)
  ll getHash(int l, int r) {
    return (mod + hash[r] - hash[l] * pow[r-l] % mod) % mod;
  }
};

char S[SIZE], T[SIZE];
int to[SIZE];
int dp[SIZE];

int main() {
  int N, M;

  scanf("%s%s", S, T);

  N = strlen(S);
  M = strlen(T);

  int loop = (M+N-1)/N;

  for (int i=1; i<loop*2; i++) {
    for (int j=0; j<N; j++) {
      S[i*N+j] = S[j];
    }
  }

  N = loop * N;


  RollingHash Shash1(1073741789, N*2, S), Shash2(1036870427, N*2, S);
  RollingHash Thash1(1073741789, M, T), Thash2(1036870427, M, T);

  for (int i=0; i<N; i++) {
    to[i] = -1;
    dp[i] = -1;
  }

  for (int i=0; i<N; i++) {
    if (Shash1.getHash(i, i+M) == Thash1.getHash(0, M) &&
        Shash2.getHash(i, i+M) == Thash2.getHash(0, M)) {

      to[i] = (i + M) % N;

      if (to[i] == i) {
        cout << -1 << endl;
        return 0;
      }
    }
  }

  for (int i=0; i<N; i++) {
    int now = i;
    int counter = 0;
    while(to[now] != -1 && to[now] != i) {
      if (dp[now] != -1) {
        counter = counter + dp[now];
        break;
      }
      now = to[now];
      counter++;
    }

    if (to[now] == i) counter = INF;

    now = i;
    while(to[now] != -1 && to[now] != i && dp[now] == -1) {
      dp[now] = min(INF, counter);
      now = to[now];
      counter--;
    }
  }

  int ans = 0;

  for (int i=0; i<N; i++) {
    ans = max(ans, dp[i]);
  }

  if (ans == INF) {
    cout << -1 << endl;
  } else {
    cout << ans << endl;
  }



  return 0;
}