// May this submission get accepted!

#pragma GCC optimize ("O3")
#pragma GCC target ("tune=native")
#pragma GCC target ("avx")

#include <bits/stdc++.h>

// 汎用マクロ
#define ALL_OF(x) (x).begin(), (x).end()
#define REP(i,n) for (long long i=0, i##_len=(n); i<i##_len; i++)
#define RANGE(i,is,ie) for (long long i=(is), i##_end=(ie); i<=i##_end; i++)
#define DSRNG(i,is,ie) for (long long i=(is), i##_end=(ie); i>=i##_end; i--)
#define STEP(i, is, ie, step) for (long long i=(is), i##_end=(ie), i##_step = (step); i<=i##_end; i+=i##_step)
#define UNIQUE(v) do { sort((v).begin(), (v).end()); (v).erase(unique((v).begin(), (v).end()), (v).end()); } while (false)
template<class T> bool chmax(T &a, const T &b) { if (a < b) {a = b; return true;} return false; }
template<class T> bool chmin(T &a, const T &b) { if (a > b) {a = b; return true;} return false; }
#define INF 0x7FFFFFFF
#define LINF 0x7FFFFFFFFFFFFFFFLL
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
#define DUMP(q) cerr << "[DEBUG] " #q ": " << (q) << " at " __FILE__ ":" << __LINE__ << endl
#define DUMPALL(q) do { cerr << "[DEBUG] " #q ": ["; REP(DUMPALL_ITR, (q).size()) { cerr << (q)[DUMPALL_ITR] << (DUMPALL_ITR == DUMPALL_ITR_len-1 ? "" : ", "); } cerr << "] at " __FILE__ ":" << __LINE__ << endl; } while (false)
template<class T> T gcd(T a, T b) { if (a < b) std::swap(a, b); while (b) std::swap(a %= b, b); return a; }
template<class T> T lcm(const T a, const T b) { return a / gcd(a, b) * b; }

// gcc拡張マクロ
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll

// エイリアス
#define DANCE_ long
#define ROBOT_ unsigned
#define HUMAN_ signed
using  ll = DANCE_ HUMAN_ DANCE_;
using ull = DANCE_ ROBOT_ DANCE_;
using  ld = long double;
using namespace std;

// 標準入出力
struct inp {
    size_t sz;
    inp(size_t _sz = 1) : sz(_sz) {}
    template <typename T> operator T () const { T a; cin >> a; return a; }
    template <typename T> operator vector<T> () const { vector<T> a(sz); for (size_t i = 0; i < sz; i++) cin >> a[i]; return a; }
    template <typename T, typename U> operator pair<T, U> () const { T f; U s; cin >> f >> s; return pair<T, U>(f, s); }
};
inp inp1; // input one
template <typename T> void say(T &x, char end = '\n') { cout << x << end; }
template <typename T> void say(vector<T> &x, char sep = ' ', char end = '\n') { for (size_t i = 0, sz = x.size(); i < sz; i++) { cout << x[i] << (i == sz-1 ? end : sep); } }

// モジュール

template <class RandomAccessIterator>
vector<ll> common_prefix(RandomAccessIterator first, RandomAccessIterator last) {
    const ll sz = last - first;
    vector<ll> prefix(sz, 0);
    for (ll i = 1, j = 0; i < sz; i++) {
        if (i + prefix[i-j] < j + prefix[j]) {
            prefix[i] = prefix[i-j];
        } else {
            ll k = max(0LL, j + prefix[j] - i);
            while (i + k < sz && *(first + k) == *(first + (i+k))) k++;
            prefix[i] = k;
            j = i;
        }
    }
    prefix[0] = sz;
    return prefix;
}

string srepeat(const string &s, size_t n) {
    if (n == 0) {
        return "";
    } else if (n == 1) {
        return s;
    } else {
        string t = srepeat(s, n/2);
        if (n % 2)
            return t + t + s;
        else
            return t + t;
    }
}

// Union-Find モジュール
struct union_find {
    vector<ull> par;
    vector<ull> num;
    union_find(ull n) : par(n, 0), num(n, 1) { iota(ALL_OF(par), 0); }
    ull root(ull i) { return par[i] == i ? i : (par[i] = root(par[i])); }
    bool same(ull i, ull j) { return root(i) == root(j); }
    void unite(ull i, ull j) {
        ull ri = root(i);
        ull rj = root(j);
        if (ri != rj) {
            if (num[ri] > num[rj]) swap(ri, rj);
            par[ri] = rj;
            num[rj] += num[ri];
        }
    }
};

// 処理内容
int main() {
    
    ios::sync_with_stdio(false); // stdioを使うときはコメントアウトすること
    cin.tie(nullptr);            // インタラクティブ問題ではコメントアウトすること
    
    string s = inp1, t = inp1;
    ll ns = s.size(), nt = t.size();

    string ss = srepeat(s, nt / ns + 2);
    string tss = t + ss;

    auto cp = common_prefix(ALL_OF(tss));

    vector<ll> to(ns, -1);
    REP(i, ns) {
        ll pfl = min(cp[nt+i], nt);
        if (pfl == nt) {
            to[i] = (i + pfl) % ns;
        }
    }

    // DUMPALL(to);

    if (count(ALL_OF(to), -1) == to.size()) {
        cout << 0 << endl;
        return 0;
    }

    vector<vector<ll>> g(ns);
    vector<ll> indeg(ns);
    union_find uf(ns);
    REP(i, ns) {
        if (to[i] != -1) {
            g[to[i]].push_back(i);
            g[i].push_back(to[i]);
            indeg[to[i]]++;
            uf.unite(i, to[i]);
        }
    }

    vector<ll> roots; roots.reserve(ns);
    REP(i, ns) {
        if (g[i].size() && uf.root(i) == i) {
            roots.push_back(i);
        }
    }
    
    vector<ll> dp(ns, INF), from(ns, -1);
    for (ll root : roots) {
        deque<ll> q = {root};
        dp[root] = 0;
        while (q.size()) {
            ll u = q.front(); q.pop_front();
            for (ll v : g[u]) {
                if (v != from[u] && dp[v] != INF) {
                    cout << -1 << endl;
                    return 0;
                }
                if (chmin(dp[v], dp[u]+1)) {
                    q.push_back(v);
                    from[v] = u;
                }
            }
        }
    }

    vector<ll> roots2(ns, -1), ds1(ns, 0);
    REP(i, ns) {
        if (dp[i] < INF) {
            ll p = uf.root(i);
            if (chmax(ds1[p], dp[i])) {
                roots2[p] = i;
            }
        }
    }
    
    vector<ll> dp2(ns, INF);
    REP(i, ns) {
        if (roots2[i] == -1) continue;
        ll root2 = roots2[i];
        deque<ll> q2 = {root2};
        dp2[root2] = 0;
        while (q2.size()) {
            ll u = q2.front(); q2.pop_front();
            for (ll v : g[u]) {
                if (chmin(dp2[v], dp2[u]+1)) {
                    q2.push_back(v);
                }
            }
        }
    }

    ll ans = 0;
    REP(i, ns) {
        if (dp2[i] < INF) {
            chmax(ans, dp2[i]);
        }
    }
    say(ans);

}

Measured memory_bytes: 75036