#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <functional>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    long long tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (long long)value;
    return output;
}

// 有向グラフのクラス。
// ダイクストラ、ベルマン・フォード、ワーシャルフロイド、最大フローに対応。
// 最大フローを求める問題で、costをint128_tにしたらMLEしたことがあるので、costはint64_tにしておく。
class Directed_Graph {
    public:
    struct Edge { 
        int to; int64_t cost;
    };
    typedef std::vector<std::vector<Edge>> adj_list;
    adj_list G;
    int node_num;
    Directed_Graph() {}
    Directed_Graph(const int node_num_in) {
        node_num = node_num_in;
        G.resize(node_num);
    }
    void add_directed_edge(const int from, const int to, const int64_t cost) {
        Edge edge; edge.to = to; edge.cost = cost;
        G[from].push_back(edge);
    }
    void add_undirected_edge(const int node1, const int node2, const int64_t cost) {
        add_directed_edge(node1, node2, cost);
        add_directed_edge(node2, node1, cost);
    }

    // 点sからの最短距離の配列を返す。
    // 戻りの値としてint128_tを用い、初期値としてint64_tの最大値を用いるのは、dist[v] + edge.costの計算でのオーバーフローを防ぐため。
    // 正しい最短距離がint64_tの最大値を超えるような事態は想定していないので、最終的にdist[v] == std::numeric_limits<int64_t>::max()だった場合、vには到達できないことを意味する。
    std::vector<int128_t> Dijkstra(int s) const {
        std::vector<int128_t> dist;
        dist.resize(node_num, std::numeric_limits<int64_t>::max());

        typedef std::pair<int128_t, int> Pair;
        std::priority_queue <Pair, std::vector<Pair>, std::greater<Pair>> que;
        dist[s] = 0;
        que.push(Pair(0, s));

        while (!que.empty()) {
            Pair pair = que.top(); que.pop();
            int v = pair.second;
            if (dist[v] < pair.first) { continue; }
            for (Edge edge : G[v]) {
                if (dist[v] + edge.cost < dist[edge.to]) {
                    dist[edge.to] = dist[v] + edge.cost;
                    que.push(Pair(dist[edge.to], edge.to));
                }
            }
        }
        return dist;
    }

    // Dijkstra法を行った後に、各点に関する最短経路の1つ前の点を計算する。
    // Dijkstra法の中に組み込む方が自然だが、Dijkstra()を複雑にしないように分離する。
    std::vector<int> Dijkstra_prev(const int s, const std::vector<int128_t>& dist) const {
        std::vector<int> prev; prev.resize(node_num, -1);
        for (int i = 0; i < node_num; i++) {
            for (Edge edge : G[i]) {
                if (dist[i] + edge.cost == dist[edge.to]) { prev[edge.to] = i; }
            }
        }
        return prev;
    }

    // Dijkstra法で、s->t 最短路を求める。{s,...,t}の形式で出力。
    // 到達できない場合は空ベクタ、t==sの場合{s}を返す。
    std::vector<int> Dijkstra_path(const int s, const int t) const {
        std::vector<int128_t> dist = Dijkstra(s);
        std::vector<int> prev = Dijkstra_prev(s, dist);
        std::vector<int> path;
        int tmp = t;
        while (tmp != s && prev[tmp] != -1) {
            path.push_back(tmp);
            tmp = prev[tmp];
        }
        if (tmp == s) { path.push_back(tmp); }
        std::reverse(path.begin(), path.end());
        return path;
    }

    // Bellman_Ford法により、loop_numに頂点数を入れることで、sからの距離を返す。返り値のbool値は負の変数の有無。
    // loop_numを変数にせず、while文で処理する方が一般的だが、「ある頂点に距離-∞の道があるか」答えやすくするため変数にしてある。
    // Bellman_Ford(s, N)とBellman_Ford(s, N*2)の値を比べて、dist[t]が異なれば、tへの距離-∞の道がある。
    std::pair<std::vector<int128_t>, bool> Bellman_Ford(const int s, const int loop_num) {
        std::vector<int128_t> dist;
        const int128_t INF = std::numeric_limits<int64_t>::max();
        dist.resize(node_num, INF);
        dist[s] = 0;
        bool last_updated = false;
        for (int n = 1; n <= loop_num; n++) {
            for (int i = 0; i < node_num; i++) {
                if (dist[i] != INF) {
                    for (auto e : G[i]) {
                        if (dist[i] + e.cost < dist[e.to]) {
                            dist[e.to] = dist[i] + e.cost;
                            if (n == loop_num) { last_updated = true; }
                        }
                    }
                }
            }
        }
        return std::pair<std::vector<int128_t>, bool>({ dist, last_updated });
    }

    std::vector<std::vector<int128_t>> Warshall_Floyd() {
        const int128_t INF = std::numeric_limits<int64_t>::max();
        std::vector<std::vector<int128_t>> dist; dist.resize(node_num);
        for (int i = 0; i < dist.size(); i++) {
            dist[i].resize(node_num, INF);
            dist[i][i] = 0;
            for (auto e : G[i]) {
                dist[i][e.to] = std::min(dist[i][e.to], (int128_t)e.cost);
            }
        }
        for (int k = 0; k < node_num; k++) {
            for (int i = 0; i < node_num; i++) {
                for (int j = 0; j < node_num; j++) {
                    dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
                }
            }
        }
        return dist;
    }

    bool bipartite_search(const int node, const int c, std::vector<int>& ret) {
        assert(c == 1 || c == -1); assert(node < ret.size());
        if (ret[node] == -c) { return false; }
        if (ret[node] == c) { return true; }
        assert(ret[node] == 0);
        ret[node] = c;
        for (Edge e : G[node]) {
            if (!bipartite_search(e.to, -c, ret)) { return false; }
        }
        return true;
    }

    std::pair<bool, std::vector<int>> is_bipartite(const int begin, const int end) {
        std::vector<int> ret; ret.resize(end+1, 0);
        for (int i = begin; i <= end; i++) {
            if (ret[i] == 0 && !bipartite_search(i, 1, ret)) {
                return std::pair<bool, std::vector<int>>({false, ret});
            }
        }
        return std::pair<bool, std::vector<int>>({true, ret});
    }

    // beginからendまで、dfsでの帰りがけ順に並べる。
    // 帰りがけ順でuがvの後に出てきた場合、以下のいずれかが成り立つ。
    // 1. uからvに到達可能
    // 2. uからvに到達不可能かつvからuに到達不可能
    // すなわち、vからuに到達可能だが、uからvに到達不可能という事象が否定される。
    std::vector<int> dfs_postorder(const int begin, const int end) const {
        std::vector<int> ret;
        std::vector<bool> used; used.resize(end+1, false);
        std::function<void(int)> dfs = [&] (int n) {
            used[n] = true;
            for (Edge e : G[n]) {
                if (!used[e.to]) { dfs(e.to); }
            }
            ret.push_back(n);
        };
        for (int i = begin; i <= end; i++) {
            if (!used[i]) { dfs(i); }
        }
        assert(ret.size() == end - begin + 1);
        return ret;
    }

    // 元のグラフの逆辺集合を返す。
    adj_list reverse_graph() const {
        adj_list rG; rG.resize(node_num);
        for (int i = 0; i < node_num; i++) {
            for (Edge e : G[i]) {
                Edge re; re.to = i; re.cost = e.cost;
                rG[e.to].push_back(re);
            }
        }
        return rG;
    }

    // 強結合の要素をまとめたDAGにおいてトポロジカルソートされるように、強結合関係の要素に同じindexを与える。
    // 逆辺でdfsを行うため、元のグラフでは到達点から始点に到達可能である。
    // 帰りがけ順の後ろからdfsを行っているので、始点から到達点へは、元のグラフでも到達可能である。よって同じ番号が与えられるなら強結合である。
    // また強結合なら、逆辺dfsで到達可能なため、このアルゴリズムで同じ番号になることが強結合の必要十分条件である。
    // 帰りがけ順のうしろから見ているため、番号が大きい成分に関しては、到達可能 or どちらの方向にも到達不可能　のいずれかが成り立つのでトポロジカルソートできている。
    std::vector<int> scc_topological(const int begin, const int end) const {
        std::vector<int> post = dfs_postorder(begin, end);
        adj_list rG = reverse_graph();
        std::vector<int> ret; ret.resize(end+1, -1);
        int cnt = begin;
        std::function<void(int)> dfs = [&] (int n) {
            ret[n] = cnt;
            for (Edge e : rG[n]) {
                if (ret[e.to] == -1) { dfs(e.to); }
            }
        };
        for (int i = post.size()-1; 0 <= i; i--) {
            if (ret[post[i]] == -1) {
                dfs(post[i]);
                cnt++;
            }
        }
        assert(cnt <= end + 1);
        return ret;
    }

    // 閉路が存在するかどうか。閉路が存在することと、強結合要素で2つ以上の頂点を持つものは同値。
    bool has_cycle(const int begin, const int end) const {
        std::vector<int> scc = scc_topological(begin, end);
        std::unordered_set<int> st;
        for (int i = begin; i <= end; i++) {
            st.insert(scc[i]);
        }
        return st.size() < end - begin + 1;
    }

    std::pair<adj_list, std::vector<std::vector<int>>> auxilarity_network() const {
        adj_list Net;
        std::vector<std::vector<int>> Rev;
        Net.resize(node_num);
        Rev.resize(node_num);
        for (int i = 0; i < node_num; i++) {
            for (Edge e : G[i]) {
                Net[i].push_back(e);
                Rev[i].push_back(-1);
            }
        }
        for (int i = 0; i < node_num; i++) {
            for (int j = 0; j < G[i].size(); j++) {
                Edge r; r.to = i; r.cost = 0;
                Rev[i][j] = Net[G[i][j].to].size();
                Net[G[i][j].to].push_back(r);
                Rev[G[i][j].to].push_back(j);
            }
        }
        return std::pair<adj_list, std::vector<std::vector<int>>>({Net, Rev});
    }

    // Ford-Fulkerson法で増加パスを探す関数。
    int64_t dfs_increase_path(const int v, const int t, const int64_t f, std::vector<bool>& used, adj_list& Net, const std::vector<std::vector<int>>& Rev) const {
        if (v == t) { return f; }
        used[v] = true;
        for (int i = 0; i < Net[v].size(); i++) {
            Edge &e = Net[v][i];
            if (!used[e.to] && 0 < e.cost) {
                int d = dfs_increase_path(e.to, t, std::min(f, e.cost), used, Net, Rev);
                if (0 < d) {
                    e.cost -= d;
                    Net[e.to][Rev[v][i]].cost += d;
                    return d;
                }
            }
        }
        return 0;
    }

    // 補助ネットワークから元のグラフのフローを出力する関数。
    adj_list aux_to_flow(const adj_list& Net) const {
        adj_list ret; ret.resize(node_num);
        for (int i = 0; i < node_num; i++) {
            for (int j = 0; j < G[i].size(); j++) {
                ret[i].push_back(G[i][j]);
                ret[i][j].cost -= Net[i][j].cost;
            }
        }
        return ret;
    }

    // Ford-Fulkersonで最大フローを求める関数。
    std::pair<int64_t, adj_list> max_flowF(const int s, const int t) const {
        auto aux = auxilarity_network();
        int64_t flow = 0;
        while (true) {
            std::vector<bool> used; used.resize(node_num, false);
            int64_t f = dfs_increase_path(s, t, std::numeric_limits<int64_t>::max(), used, aux.first, aux.second);
            if (f == 0) { break; }
            flow += f;
        }
        return std::pair<int64_t, adj_list>({ flow, aux_to_flow(aux.first) });
    }

    // sからの最短距離をBFSで計算する。ここでの最短距離は、Netの容量1以上の辺数のことであり、辺の容量には依存しない。
    std::vector<int> bfs_level(const int s, const adj_list& Net) const {
        std::vector<int> level; level.resize(node_num, -1);
        std::queue<int> que;
        level[s] = 0;
        que.push(s);
        while(!que.empty()) {
            const int v = que.front(); que.pop();
            for (int i = 0; i < Net[v].size(); i++) {
                const Edge& e = Net[v][i];
                if (0 < e.cost && level[e.to] == -1) { // 全ての辺は距離1なので、BFSでは1つの点は1度だけpushすればよい。
                    level[e.to] = level[v] + 1;
                    que.push(e.to);
                }
            }
        }
        return level;
    }

    // 増加パスをDFSで探す。v 現在地, t 終点, f 現状流せる最大流
    int64_t dfs_increase_path(const int v, const int t, const int64_t f, std::vector<int>& iter, adj_list& Net, const std::vector<std::vector<int>>& Rev, const std::vector<int>& level) const {
        if (v == t) return f;
        for (int &i = iter[v]; i < Net[v].size(); i++) {
            Edge &e = Net[v][i];
            if (0 < e.cost && level[v] < level[e.to]) { // 距離が増加するパスだけを対象にする。
                const int64_t d = dfs_increase_path(e.to, t, std::min(f, e.cost), iter, Net, Rev, level);
                if (d > 0) {
                    e.cost -= d;
                    Net[e.to][Rev[v][i]].cost += d;
                    return d;
                }
            }
        }
        return 0;
    }

    // Dinic法で最大フローを求める。
    std::pair<int64_t, adj_list> max_flowD(const int s, const int t) const {
        auto aux = auxilarity_network();
        int64_t flow = 0;
        while (true) {
            std::vector<int> level = bfs_level(s, aux.first);
            if (level[t] == -1) { break; }
            std::vector<int> iter; iter.resize(node_num, 0);
            int64_t f;
            while ((f = dfs_increase_path(s, t, std::numeric_limits<int64_t>::max(), iter, aux.first, aux.second, level)) > 0) {
                flow += f;
            }
            //距離増加パスに流せるだけ流せたら、最短の増加パスの長さは真に増加する。
        }
        return std::pair<int64_t, adj_list>({ flow, aux_to_flow(aux.first) });
    }
};

std::vector<int> Zalgorithm(const std::string& S) {
    std::vector<int> Z; Z.resize(S.size(), 0);
    int c = 0;
    for (int i = 1; i < S.size(); i++){
        if (i + Z[i-c] < c + Z[c]) {
            Z[i] = Z[i-c];
        } else {
            int j = std::max(0, c + Z[c] - i);
            while (i + j < S.size() && S[j] == S[i+j]) { ++j; }
            Z[i] = j;
            c = i;
        }
    }
    Z[0] = S.size();
    return Z;
}

#define rep(i, begin, end) for(int64_t i = (begin); i <= (end); i++)
#define rev(i, begin, end) for(int64_t i = (begin); (end) <= i; i--)

void printvec(const std::vector<int>& vec) {
    for (int i = 0; i < vec.size(); i++) { std::cout << vec[i] << " "; } std::cout << std::endl;
}

std::string s, t;

const int MAX_N = 5e5 + 10;
Directed_Graph dg(MAX_N);

int dp[MAX_N];

int calc(int i) {
    if (dp[i] != -1) {
        return dp[i];
    }

    int ret = 0;
    for (auto e : dg.G[i]) {
        ret = std::max(ret, calc(e.to) + 1);
    }
    dp[i] = ret;
    return ret;
}

int main(int argc, char **argv) {
    std::cin >> s;
    std::cin >> t;

    std::string u = s;

    while (u.size() < s.size() + t.size()) {
        u += s;
        /*
        rep (i, 0, s.size() - 1) {
            u.push_back(s[i]);
        }
        */
        //u = u + s;
    }

    //assert(false);

    std::string v = t + "?" + u;

    std::vector<int> Z = Zalgorithm(v);

    //assert(false);

    //printvec(Z);

    rep (i, 0, s.size() - 1) {
        if (t.size() <= Z[t.size() + 1 + i]) {
            int next = (i + t.size()) % s.size();
            if (next == i) {
                std::cout << -1 << std::endl;
                return 0;
            }
            dg.add_directed_edge(i, next, 1);
            //std::cout << "e:" << i << " " << next << std::endl;
        }
    }

    if (dg.has_cycle(0, s.size() - 1)) {
        std::cout << -1 << std::endl;
        return 0;
    }

    rep (i, 0, s.size() - 1) {
        dp[i] = -1;
    }

    int ret = 0;

    rep (i, 0, s.size() - 1) {
        ret = std::max(ret, calc(i));
    }
    
    std::cout << ret << std::endl;

    return 0;
}

Measured memory_bytes: 94512