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 OCaml (4.02.3) (judge verdict: Accepted)

let readString () = Scanf.scanf " %s" (fun s -> s)

let borders s =
  let n = String.length s in
  let b = Array.make (n+1) (-1) in
  for i=0 to n-1 do
    let j = ref b.(i) in
    while !j >= 0 && s.[!j] <> s.[i] do
      j := b.(!j)
    done;
    b.(i+1) <- !j+1
  done;
  b

type result = [`Unknown | `Cycle | `Length of int]
type knownResult = [`Cycle | `Length of int]

let rec compare (a: result) (b: result) =
  match (a, b) with
  | (`Unknown, `Unknown) -> 0
  | (`Cycle, `Cycle) -> 0
  | (`Length x, `Length y) -> Pervasives.compare x y
  | (`Unknown, _) -> -1
  | (`Cycle, _) -> 1
  | _ -> -(compare b a)

let solve s t : knownResult =
  let n = String.length s in
  let m = String.length t in
  let b = borders t in
  let yes = Array.make n false in
  let j = ref 0 in
  for i=0 to n+m-2 do
    while !j >= 0 && (!j >= m || t.[!j] <> s.[i mod n]) do
      j := b.(!j)
    done;
    incr j;
    if !j = m then yes.(i+1-m) <- true
  done;
  let plen: result array = Array.make n `Unknown in
  let rec calc ?(start = None) i : knownResult =
    let i0 = match start with None -> i | Some i0 -> i0 in
    match plen.(i) with
    | `Unknown ->
        begin
          let ans =
            if start <> None && i = i0 then `Cycle
            else if not yes.(i) then `Length 0
            else
              match calc ~start:(Some i0) ((i + m) mod n) with
              | `Cycle -> `Cycle
              | `Length x -> `Length (1 + x)
          in
          plen.(i) <- ans;
          ans
        end
    | `Cycle -> `Cycle
    | `Length x -> `Length x
  in
  let res: knownResult ref = ref (`Length 0) in
  for i=0 to n-1 do
    let x = calc i in
    if compare (!res :> result) (x :> result) < 0 then res := x
  done;
  match !res with
  | `Cycle -> `Cycle
  | `Length x -> `Length x

let main () =
  let s = readString () in
  let t = readString () in
  Printf.printf "%d\n" (match solve s t with `Cycle -> -1 | `Length x -> x)

let () = main ()