//#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 <cstdint>
#include <vector>

namespace n91 {

	template <class Base> struct mersenne61_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;

		template <int Width> static constexpr u64 div(const u64 v) noexcept {
			return v >> Width;
		}

		template <int Width> static constexpr u64 mod(const u64 v) noexcept {
			return v & (static_cast<u64>(1) << Width) - static_cast<u64>(1);
		}

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

		static constexpr u64 shl31(const u64 v) noexcept {
			return (mod<30>(v) << 31) + div<30>(v);
		}
		static constexpr u64 calc(u64 v) noexcept {
			if (v > Modulus) {
				v = div<61>(v) + mod<61>(v);
			}
			if (v > Modulus) {
				return v -= Modulus;
			}
			return v;
		}
		static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
			const u64 lu = div<31>(l), ld = mod<31>(l), ru = div<31>(r),
				rd = mod<31>(r);
			return calc((lu * ru << 1) + ld * rd + shl31(lu * rd + ru * ld));
		}
		static constexpr u64 multiplies_plus(const u64 l, const u64 r,
			const u64 c) noexcept {
			const u64 lu = div<31>(l), ld = mod<31>(l), ru = div<31>(r),
				rd = mod<31>(r);
			return calc((lu * ru << 1) + ld * rd + shl31(lu * rd + ru * ld) + c);
		}

		container_type prefix, power;

	public:
		template <class InputIterator>
		explicit mersenne61_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],
				Modulus - prefix[last]);
		}
	};

} // namespace n91

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

namespace n91 {

	void main_() {
		using hash = mersenne61_rolling_hash<std::integral_constant<u64, 100>>;
		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;
}


Measured memory_bytes: 49728