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 CompLib.Collections;
using CompLib.Util;
using System;
using System.Linq;
using System.Text;

public class Program
{
    string S, T;
    string SS;

    long[] Memo;

    bool[] Table;

    bool[] Flag;

    long Len(int index)
    {
        if (Memo[index] == -1)
        {
            if (Table[index])
            {
                int next = (index + T.Length) % S.Length;
                Flag[index] = true;
                Memo[index] = Flag[next] ? int.MaxValue : Len((index + T.Length) % S.Length) + 1;
                Flag[index] = false;
            }
            else
            {
                Memo[index] = 0;
            }
        }
        return Memo[index];
    }

    public void Solve()
    {
        var sc = new Scanner();
        S = sc.Next();
        T = sc.Next();

        var sb = new StringBuilder();
        while (sb.Length < T.Length)
        {
            sb.Append(S);
        }
        S = sb.ToString();
        SS = S + S;

        var kmp = new KMP(T.ToCharArray());
        Table = kmp.Calc(SS.ToCharArray());

        Flag = new bool[S.Length];
        Memo = new long[S.Length];
        for (int i = 0; i < S.Length; i++)
        {
            Memo[i] = -1;
        }

        long max = 0;
        for (int i = 0; i < S.Length; i++)
        {
            max = Math.Max(max, Len(i));
        }

        Console.WriteLine(max >= int.MaxValue ? -1 : max);
    }

    public static void Main(string[] args) => new Program().Solve();
}
namespace CompLib.Collections
{
    using Num = Char;
    class KMP
    {
        private Num[] _pattern;
        private int[] _table;
        public KMP(Num[] pattern)
        {
            _pattern = pattern;
            _table = new int[pattern.Length + 1];
            _table[0] = 0;
            var j = 0;
            for (int i = 1; i < pattern.Length; i++)
            {
                if (pattern[i] == pattern[j])
                {
                    _table[i] = j++;
                }
                else
                {
                    _table[i] = j;
                    j = 0;
                }
            }
            _table[pattern.Length] = j;
        }

        // result[i] target[i]以降がpatternに一致する
        public bool[] Calc(Num[] target)
        {
            var result = new bool[target.Length];
            int i = 0, p = 0;
            while (i < target.Length)
            {
                // 一致してたら次に

                if (p == _pattern.Length)
                {
                    result[i - p] = true;
                    p = _table[p];
                }
                else if (target[i] == _pattern[p])
                {
                    i++;
                    p++;
                }
                else if (p == 0)
                {
                    i++;
                }
                else
                {
                    p = _table[p];
                }
            }

            if (p == _pattern.Length)
            {
                result[i - p] = true;
            }

            return result;
        }
    }
}
namespace CompLib.Util
{
    using System;
    using System.Linq;
    class Scanner
    {
        private int _index;
        private string[] _line;
        const char separator = ' ';

        public Scanner()
        {
            _index = 0;
            _line = new string[0];
        }

        public string Next()
        {
            while (_index >= _line.Length)
            {
                _line = Console.ReadLine().Split(separator);
                _index = 0;
            }
            return _line[_index++];
        }
        public int NextInt() => int.Parse(Next());
        public long NextLong() => long.Parse(Next());
        public double NextDouble() => double.Parse(Next());
        public char NextChar() => Next()[0];
        public char[] NextCharArray() => Next().ToCharArray();

        public string[] Array()
        {
            _line = Console.ReadLine().Split(separator);
            _index = _line.Length;
            return _line;
        }
        public int[] IntArray() => Array().Select(int.Parse).ToArray();
        public long[] LongArray() => Array().Select(long.Parse).ToArray();
        public double[] DoubleArray() => Array().Select(double.Parse).ToArray();
    }
}