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# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ABC135F
{
    class Program
    {
        static void Main(string[] args)
        {
            var S = Console.ReadLine();
            var T = Console.ReadLine();

            if (S.Distinct().Count() == 1 && T.Distinct().Count() == 1 && S[0] == T[0])
            {
                Console.WriteLine(-1);
                return;
            }

            S += S + S;
            //SをTの二倍まで延長
            StringBuilder sb = new StringBuilder(S);
            while (sb.Length < T.Length * 3)
            {
                sb.Append(S);
            }
            S = sb.ToString();

            RollingHash rhS = new RollingHash(S);
            RollingHash rhT = new RollingHash(T);

            var hash = rhT.Get(0, T.Length);
            int[] match = new int[S.Length - T.Length + 1];
            for (int i = 0; i <= S.Length - T.Length; i++)
            {
                if (hash == rhS.Get(i, i + T.Length))
                {
                    if (i - T.Length >= 0)
                        match[i] = match[i - T.Length] + 1;
                    else match[i] = 1;
                }
            }

            //forDebug
            //Console.WriteLine(string.Join(",", match));

            //繰り返しの判定
            int max = 0;
            int maxIndex = -1;
            int firstIndex = -1;
            for (int i = 0; i < match.Length; i++)
            {
                if (match[i] > max)
                {
                    max = match[i]; maxIndex = i;
                }
            }

            if (max != 0)
            {
                //firstIndex = maxIndex - (max - 1) * T.Length;

                //string remain = S.Substring(maxIndex + T.Length) + S.Substring(0, firstIndex);
                //if (remain == T)
                //{
                //    Console.WriteLine(-1);
                //    return;
                //}
                int repeat = (S.Length - 1) / T.Length;
                if (max >= repeat)
                {
                    Console.WriteLine(-1);
                    return;
                }
            }

            Console.WriteLine(max);
            Console.ReadKey();
        }

        static int[] ReadInt()
        {
            int[] ret = Console.ReadLine().Split().Select(int.Parse).ToArray();
            return ret;
        }
        static long[] ReadLong()
        {
            long[] ret = Console.ReadLine().Split().Select(long.Parse).ToArray();
            return ret;
        }
    }

    class RollingHash
    {
        const long B = 1000000009;
        string S;
        int N;
        ulong[] Power;
        ulong[] Hash;
        public RollingHash(string s)
        {
            S = s;
            N = s.Length;

            Power = new ulong[N + 1];
            Power[0] = 1;
            for (int i = 0; i < N; i++)
            {
                Power[i + 1] = Power[i] * B;
            }

            Hash = new ulong[N + 1];
            for (int i = 0; i < N; i++)
            {
                Hash[i + 1] = Hash[i] * B + S[i];
            }
        }
        // S[l, r) のハッシュ値を求める
        public ulong Get(int l, int r)
        {
            var hash = Hash[r] - Hash[l] * Power[r - l];
            return hash;
        }
    }
}