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++14 (GCC 5.4.1) (judge verdict: Accepted)

//#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>

namespace n91 {

	using i8 = std::int_fast8_t;
	using i32 = std::int_fast32_t;
	using i64 = std::int_fast64_t;
	using u8 = std::uint_fast8_t;
	using u32 = std::uint_fast32_t;
	using u64 = std::uint_fast64_t;
	using isize = std::ptrdiff_t;
	using usize = std::size_t;

	constexpr usize operator"" _z(unsigned long long x) noexcept {
		return static_cast<usize>(x);
	}

	class rep {
		const usize f, l;

	public:
		class itr {
			friend rep;
			usize i;
			constexpr itr(const usize x) noexcept : i(x) {}

		public:
			void operator++() noexcept { ++i; }
			constexpr usize operator*() const noexcept { return i; }
			constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
		};
		constexpr rep(const usize first, const usize last) noexcept
			: f(first), l(last) {}
		constexpr itr begin() const noexcept { return itr(f); }
		constexpr itr end() const noexcept { return itr(l); }
	};
	class revrep {
		const usize f, l;

	public:
		class itr {
			friend revrep;
			usize i;
			constexpr itr(usize x) noexcept : i(x) {}

		public:
			void operator++() noexcept { --i; }
			constexpr usize operator*() const noexcept { return i; }
			constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
		};
		constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
		constexpr itr begin() const noexcept { return itr(l); }
		constexpr itr end() const noexcept { return itr(f); }
	};
	template <class T> using vec_alias = std::vector<T>;
	template <class T> auto md_vec(const usize n, const T& value) {
		return std::vector<T>(n, value);
	}
	template <class... Args> auto md_vec(const usize n, Args... args) {
		return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
	}
	template <class T> constexpr T difference(const T& a, const T& b) {
		return a < b ? b - a : a - b;
	}
	template <class T> T scan() {
		T ret;
		std::cin >> ret;
		return ret;
	}

} // namespace n91

#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>

namespace n91 {

#include <cstdint>
#include <vector>

	template <class Base> struct m2e61m1_rolling_hash {
		using u64 = std::uint_fast64_t;
		using value_type = u64;
		using container_type = std::vector<value_type>;
		using size_type = typename container_type::size_type;

		static constexpr u64 pow2(const int exp) noexcept {
			return static_cast<u64>(1) << exp;
		}

		static constexpr u64 Mod = pow2(61) - static_cast<u64>(1);

		static constexpr u64 cyclic(const u64 v) noexcept {
			return v % pow2(30) * pow2(31) + v / pow2(30);
		}
		static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
			const u64 lu = l / pow2(31), ld = l % pow2(31), ru = r / pow2(31),
				rd = r % pow2(31);

			return (lu * ru * static_cast<u64>(2) + ld * rd +
				cyclic(lu * rd + ru * ld)) %
				Mod;
		}
		static constexpr u64 multiplies_plus(const u64 l, const u64 r,
			const u64 c) noexcept {
			const u64 lu = l / pow2(31), ld = l % pow2(31), ru = r / pow2(31),
				rd = r % pow2(31);

			return (lu * ru * static_cast<u64>(2) + ld * rd +
				cyclic(lu * rd + ru * ld) + c) %
				Mod;
		}

		container_type prefix, power;

	public:
		template <class InputIterator>
		explicit m2e61m1_rolling_hash(InputIterator first,
			const InputIterator last) noexcept
			: prefix(), power() {
			const size_type n = static_cast<size_type>(std::distance(first, last));
			prefix.reserve(n + static_cast<size_type>(1));
			prefix.push_back(static_cast<value_type>(0));
			for (; first != last; ++first) {
				prefix.push_back(multiplies_plus(prefix.back(), Base::value, *first));
			}
			power.reserve(n + static_cast<size_type>(1));
			power.push_back(static_cast<value_type>(1));
			for (size_type i = static_cast<size_type>(0); i != n; ++i) {
				power.push_back(multiplies(power.back(), Base::value));
			}
		}

		value_type operator()(const size_type first, const size_type last) const
			noexcept {
			return multiplies_plus(prefix[first], power[last - first],
				Mod - prefix[last]);
		}
	};


	void main_() {
		using hash = m2e61m1_rolling_hash<std::integral_constant<u64,62479294>>;
		auto s = scan<std::string>();
		const auto t = scan<std::string>();
		const usize m = t.size();
		while (s.size() < m) {
			s = s + s;
		}
		const usize n = s.size();
		s = s + s;
		const hash sh(s.cbegin(),s.cend());
		const u64 th = hash(t.cbegin(),t.cend())(0_z, m);
		std::vector<usize> next(n, n), prev(n, n);
		for (const auto i : rep(0_z, n)) {
			if (sh(i, i + m) == th) {
				next[i] = (i + m) % n;
				prev[next[i]] = i;
			}
		}
		usize r_cnt = 0_z;
		usize ans = 0_z;
		for (const auto i : rep(0_z, n)) {
			if (prev[i] == n) {
				++r_cnt;
				usize count = 0_z;
				usize v = next[i];
				while (v != n) {
					++r_cnt;
					v = next[v];
					++count;
				}
				ans = std::max(ans, count);
			}
		}
		if (r_cnt == n) {
			std::cout << ans << std::endl;
		}
		else {
			std::cout << "-1" << std::endl;
		}
	}

} // namespace n91

int main() {
	n91::main_();
	return 0;
}