#include <bits/stdc++.h>

using i64 = long long;
struct SAM {
    static constexpr int ALPHABET_SIZE = 26;
    struct Node {
        int len;
        int link;
        std::array<int, ALPHABET_SIZE> next;
        Node() : len{}, link{}, next{} {}
    };
    std::vector<Node> t;
    SAM() {
        init();
    }
    void init() {
        t.assign(2, Node());
        t[0].next.fill(1);
        t[0].len = -1;
    }
    int newNode() {
        t.emplace_back();
        return t.size() - 1;
    }
    int extend(int p, int c) {
        if (t[p].next[c]) {
            int q = t[p].next[c];
            if (t[q].len == t[p].len + 1) {
                return q;
            }
            int r = newNode();
            t[r].len = t[p].len + 1;
            t[r].link = t[q].link;
            t[r].next = t[q].next;
            t[q].link = r;
            while (t[p].next[c] == q) {
                t[p].next[c] = r;
                p = t[p].link;
            }
            return r;
        }
        int cur = newNode();
        t[cur].len = t[p].len + 1;
        while (!t[p].next[c]) {
            t[p].next[c] = cur;
            p = t[p].link;
        }
        t[cur].link = extend(p, c);
        return cur;
    }
    int extend(int p, char c, char offset = 'a') {
        return extend(p, c - offset);
    }
    
    int next(int p, int x) {
        return t[p].next[x];
    }
    
    int next(int p, char c, char offset = 'a') {
        return next(p, c - 'a');
    }
    
    int link(int p) {
        return t[p].link;
    }
    
    int len(int p) {
        return t[p].len;
    }
    
    int size() {
        return t.size();
    }
};
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::string s, t;
    std::cin >> s >> t;
    
    SAM sam;
    for (int p = 1; auto c : t) {
        p = sam.extend(p, c);
    }
    int p = 1;
    int l = -1, r = 0;
    int ans = -1E9;
    int n = s.size();
    for (int i = 0, j = i, p = 1; i < n; i++) {
        if (j - i <= sam.len(sam.link(p))) {
            p = sam.link(p);
        }
        while (j < n && sam.next(p, s[j])) {
            p = sam.next(p, s[j++]);
        }
        int v = j - i - std::max(i, n - j);
        if (j > i && v > ans) {
            ans = v;
            l = i;
            r = j;
        }
    }
    std::cout << l << " " << r - 1 << "\n";
    
    return 0;
}