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.Numerics;

public class Program
{
    private string S, T;
    private bool[] Match, B;
    private int SLength;
    private int[] Memo;

    public void Solve()
    {
        var sc = new Scanner();
        S = sc.Next();
        T = sc.Next();
        SLength = S.Length;
        Match = new bool[SLength];
        B = new bool[SLength];
        Memo = new int[SLength];
        for (int i = 0; i < SLength; i++)
        {
            Memo[i] = -1;
        }

        BigInteger tBInt = 0;
        foreach (char c in T)
        {
            tBInt *= 10;
            tBInt += c - 'a';
        }

        BigInteger tmpSInt = 0;
        for (int i = 0; i < T.Length; i++)
        {
            tmpSInt *= 26;
            tmpSInt += S[i % S.Length] - 'a';
        }

        var pow = BigInteger.Pow(26, T.Length);
        for (int i = 0; i < S.Length; i++)
        {
            if (tBInt == tmpSInt)
            {
                Match[i] = true;
            }
            tmpSInt *= 26;
            tmpSInt %= pow;
            tmpSInt += S[(i + T.Length) % S.Length] - 'a';
        }

        int max = 0;
        for (int i = 0; i < SLength; i++)
        {
            int c = Calc(i);
            if (c == -1)
            {
                Console.WriteLine(-1);
                return;
            }

            max = Math.Max(max, c);
        }

        Console.WriteLine(max);
    }

    // iから初めていくつ繋げられるか
    private int Calc(int i)
    {
        if (B[i])
        {
            return -1;
        }

        if (Memo[i] != -1)
        {
            return Memo[i];
        }

        if (!Match[i])
        {
            Memo[i] = 0;
            return 0;
        }
        else
        {
            B[i] = true;
            int result = Calc((i + T.Length) % SLength);
            B[i] = false;
            if (result == -1)
            {
                return -1;
            }

            Memo[i] = result + 1;
            return result + 1;
        }
    }

    public static void Main(string[] args)
    {
        new Program().Solve();
    }
}

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

    const char Separator = ' ';
    private int _pos;
    private string[] _line;

    #region スペース区切りで取得

    public string Next()
    {
        if (_pos >= _line.Length)
        {
            _line = Console.ReadLine().Split(Separator);
            _pos = 0;
        }

        return _line[_pos++];
    }

    public int NextInt()
    {
        return int.Parse(Next());
    }

    public long NextLong()
    {
        return long.Parse(Next());
    }

    public double NextDouble()
    {
        return double.Parse(Next());
    }

    #endregion

    #region 型変換

    private int[] ToIntArray(string[] array)
    {
        var result = new int[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = int.Parse(array[i]);
        }

        return result;
    }

    private long[] ToLongArray(string[] array)
    {
        var result = new long[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = long.Parse(array[i]);
        }

        return result;
    }

    private double[] ToDoubleArray(string[] array)
    {
        var result = new double[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = double.Parse(array[i]);
        }

        return result;
    }

    #endregion

    #region 配列取得

    public string[] Array()
    {
        if (_pos >= _line.Length)
            _line = Console.ReadLine().Split(Separator);

        _pos = _line.Length;
        return _line;
    }

    public int[] IntArray()
    {
        return ToIntArray(Array());
    }

    public long[] LongArray()
    {
        return ToLongArray(Array());
    }

    public double[] DoubleArray()
    {
        return ToDoubleArray(Array());
    }

    #endregion
}