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 S2 = Console.ReadLine();
            var T = Console.ReadLine();

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

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

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

            var hash = rhT.Get(0, T.Length);
            var hashU = rhT.GetU(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) && hashU == rhS.GetU(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 = match.Max();
            if (max != 0)
            {
                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
    {
        ulong B;
        const ulong mod = 100000009;
        string S;
        int N;
        ulong[] Power;
        ulong[] PowerU;
        ulong[] Hash;
        ulong[] HashU;
        public RollingHash(string s)
        {
            Random r = new Random();
            B = (ulong)r.Next(100000, 1000000);

            S = s;
            N = s.Length;

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

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