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;

    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());
        bool[] table = kmp.Calc(SS.ToCharArray());


        long[] len = new long[S.Length];


        for (int i = 0; i < T.Length; i++)
        {
            len[i] = table[i] ? 1 : 0;
        }
        for (int i = T.Length; i < S.Length; i++)
        {
            len[i] = table[i] ? len[i - T.Length] + 1 : 0;
        }

        for (int i = 0; i < S.Length; i++)
        {
            int prev = (i - T.Length) % S.Length;
            if (prev < 0) prev += S.Length;
            len[i] = table[i] ? len[prev] + 1 : 0;
        }

        // 2週目でも更新するなら
        for (int i = 0; i < S.Length; i++)
        {
            int prev = (i - T.Length) % S.Length;
            if (prev < 0) prev += S.Length;
            long t = table[i] ? len[prev] + 1 : 0;
            if(t != len[i])
            {
                Console.WriteLine(-1);
                return;
            }
        }

        Console.WriteLine(len.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();
    }
}