#include <bits/stdc++.h>

using namespace std;

#define ll long long

struct RollingHash {
	string text; // text
	int n; // number of characters
	int base1 = 1009;
	int base2 = 1007;
	ll mod1 = (ll)1e9 + 9;
	ll mod2 = (ll)1e9 + 7;
	ll* pow1;
	ll* pow2;
	ll* hash1;
	ll* hash2;
	/* constructor */
	RollingHash(string s) {
		text = s;
		n = text.size();
		hash1 = new ll[n + 1];
		hash2 = new ll[n + 1];
		pow1 = new ll[n + 1];
		pow2 = new ll[n + 1];
		hash1[0] = hash2[0] = 0;
		pow1[0] = pow2[0] = 1;
		for (int i = 0; i < n; ++i) {
			hash1[i + 1] = (hash1[i] + text[i]) * base1 % mod1;
			hash2[i + 1] = (hash2[i] + text[i]) * base2 % mod2;
			pow1[i + 1] = pow1[i] * base1 % mod1;
			pow2[i + 1] = pow2[i] * base2 % mod2;
		}
	}
	/* calculate the hash value of text[l,l+1,...,r-1] */
	pair<ll, ll> get(ll l, ll r) {
		if (l == r) return make_pair((ll)0, (ll)0);
		pair<ll, ll> p;
		p.first = ((hash1[r] - hash1[l] * pow1[r - l] % mod1) + mod1) % mod1;
		p.second = ((hash2[r] - hash2[l] * pow2[r - l] % mod2) + mod2) % mod2;
		return p;
	}
	/* calculate a^b mod m */
	ll modpow(ll a, ll b, ll m) {
		if (b == 0) return 1;
		ll t = modpow(a, b / 2, m);
		if (b & 1) {
			return t * t % m * a % m;
		}
		return t * t % m;
	}
	/* calculate the hash value of text+text+...+text */
	pair<ll, ll> rep(ll k) {
		auto hs = get(0, n);
		if (k == 1) return hs;
		auto t = rep(k / 2);
		pair<ll, ll> new_hs;
		new_hs.first = (t.first + t.first * modpow(base1, n * (k / 2), mod1) % mod1) % mod1;
		new_hs.second = (t.second + t.second * modpow(base2, n * (k / 2), mod2) % mod2) % mod2;
		if (k & 1) {
			new_hs.first = (new_hs.first * pow1[n] % mod1 + hs.first) % mod1;
			new_hs.second = (new_hs.second * pow2[n] % mod2 + hs.second) % mod2;
			return new_hs;
		}
		return new_hs;
	}
	/* calculate the hash value of text[k,k+1,...,n-1]text[0,1,...,k-1] */
	pair<ll, ll> rot(ll k) {
		auto h1 = get(k, n);
		auto h2 = get(0, k);
		ll f = (h1.first * pow1[k] % mod1 + h2.first) % mod1;
		ll s = (h1.second * pow2[k] % mod2 + h2.second) % mod2;
		return make_pair(f, s);
	}
};

// 文字列a,bについて、次のようなjの最大値を求める.
//    aのなかにbをj個連結したものが含まれる
// ただし、0より大きいことが保証されている.
ll solve(RollingHash a, RollingHash b) {
	// 常に
	//   left : aのなかにbをleft個連結したものが含まれる
	//   right : aのなかにbをright個連結したものが含まれない
	// を満たすように、right-left>1の間更新していく.
	ll left = 1;
	ll right = ((ll)a.n) / ((ll)b.n) + 1;
	while (right - left > 1) {
		ll mid = left + (right - left) / 2;
		// aの中にbをmid個連結したものが含まれるか判定する.
		auto hs = b.rep(mid); // bをmid個連結したもののハッシュ値
		bool f = false; // 含まれるかどうかのフラグ
		for (ll i = 0; i <= a.n - mid * b.n; ++i) {
			auto hs_asub = a.get(i, i + b.n * mid);
			f = (hs_asub == hs);
			if (f) break;
		}
		if (f) left = mid;
		else right = mid;
	}
	return left;
}

// 最大公約数を求める
ll gcd(ll a, ll b) {
	if (a < b) return gcd(b, a);
	ll r;
	while (r = a % b) {
		a = b;
		b = r;
	}
	return b;
}

signed main() {
	// 入力の受け取り
	string s, t;
	cin >> s >> t;

	// sの長さがtの長さより大きくなるように、sを繰り返す
	string new_s = "";
	while (new_s.length() <= t.length())
		new_s += s;
	s = new_s;

	// sとtのローリングハッシュを構成
	RollingHash rhs(s);
	RollingHash rht(t);

	// 答えが-1になるか判定する.
	// sの長さとtの長さの最大公約数をgとして、
	// ・tが周期gをもつ.
	// ・sを回転させると周期gをもつ.
	// ・2つの周期文字列が同一.
	// 上の3つが満たされるなら、-1.
	ll g = gcd(s.length(), t.length());
	string sub = t.substr(0, g); // tの先頭g文字
	RollingHash hssub(sub);
	bool f = false;
	auto reps = hssub.rep(s.length() / g);
	if (hssub.rep(t.length() / g) != rht.get(0, t.length())) goto Next;
	for (ll i = 0; i < s.length(); ++i) {
		if (rhs.rot(i) == reps) {
			f = true;
			break;
		}
	}
	if (f) {
		cout << "-1" << endl;
		return 0;
	}

Next:;

	// 答えが0になるかを判定する.
	// s+s+sの部分文字列として、tが含まれなければ0.
	RollingHash rhs2(s + s + s);
	auto hash_t = rht.get(0, t.length());
	f = false; // 含まれているかのフラグ
	for (ll i = 0; i <= ((ll)s.length()) * 3 - t.length(); ++i) {
		auto hash_ssub = rhs2.get(i, i + t.length());
		f = (hash_t == hash_ssub);
		if (f) break;
	}
	if (!f) { // 含まれていなければ0
		cout << "0" << endl;
		return 0;
	}

	// s+s+s中にtを何個連結したものが含まれるかを計算する.
	// これが答えとなる.
	ll ans = solve(rhs2, rht);
	cout << ans << endl;

	return 0;
}

Measured memory_bytes: 167308