#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
 
using namespace std;
using namespace __gnu_pbds;
 
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
 
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
 
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
 
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
 
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= a; i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
 
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define shandom_ruffle random_shuffle
 
const int MOD = 1610612741;
const ll INF = 1e18;
const int MX = 100001; //check the limits, dummy
 
ll modExp(ll base, ll power) {
    if (power == 0) {
        return 1;
    } else {
        ll cur = modExp(base, power / 2); cur = cur * cur; cur = cur % MOD;
        if (power % 2 == 1) cur = cur * base;
        cur = cur % MOD;
        return cur;
    }
}
 
ll inv(ll base) {
    return modExp(base, MOD-2);
}
 
ll mul(ll A, ll B) {
    return (A*B)%MOD;
}
 
ll add(ll A, ll B) {
    return (A+B)%MOD;
}
 
ll dvd(ll A, ll B) {
    return mul(A, inv(B));
}
 
ll sub(ll A, ll B) {
    return (A-B+MOD)%MOD;
}
 
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
 
    string S, T; cin >> S >> T;
    int N = sz(S), M = sz(T);
    int total = 0, count = 0;
    while (total < M) {
        total += N; count++;
    }
    total += N; count++;
 
    string L(count*N, '*');
    int K = sz(L);
    F0R(i, K) {
        L[i] = S[i % N];
    }
 
    ll hsh = 805306457;
 
    ll hashT = 0;
    F0Rd(i, M) {
        hashT *= hsh; hashT %= MOD;
        hashT += T[i] - 'a'; hashT %= MOD;
    }
 
    ll hashS = 0;
    ll bigPower = modExp(hsh, M);
    bool valid[N]; F0R(i, N) valid[i] = false;
    //cout << hashT << endl;
    F0Rd(i, K) {
        hashS = mul(hashS, hsh);
        hashS = add(hashS, L[i] - 'a');
        if (i + M < K) {
            hashS = sub(hashS, mul(L[i+M] - 'a', bigPower));
        }
        if (i < N && hashS == hashT) {
            valid[i] = true;
            //cout << i << " is valid" << endl;
        }
        //cout << i << " " << hashS << endl;
 
    }
 
 
 
    int starter[N]; F0R(i, N) starter[i] = 0;
 
 
    int succ[N]; F0R(i, N) succ[i] = -1;
    F0R(i, N) {
        if (valid[i]) {
            //cout << i << " is valid" << endl;
            succ[i] = (i+M)%N;
            starter[(i+M)%N]++;
        }
    }
 
    queue<int> q;
    int dist[N]; F0R(i, N) dist[i] = -1;
    F0R(i, N) {
        if (starter[i] == 0) {
            dist[i] = 0;
            q.push(i);
        }
    }
 
    while (!q.empty()) {
        int cur = q.front(); q.pop();
        if (succ[cur] == -1) continue;
        int nxt = succ[cur];
        starter[succ[cur]]--;
        dist[nxt] = max(dist[nxt], dist[cur] + 1);
        if (starter[nxt] == 0) {
            q.push(nxt);
 
        }
    }
 
    int bestDist = -1;
    F0R(i, N) {
        bestDist = max(bestDist, dist[i]);
        if (dist[i] == -1) {
            cout << -1 << endl; return 0;
        }
    }
 
    cout << bestDist << endl;
 
 
 
 
    return 0;
}

Measured memory_bytes: 11164