#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <bits/stdc++.h>

using namespace std;

const int maxn = (int)2e6 + 2;
const int inf = -(int)1e9;

#define left asdasd
#define right fsfsdfs


#define rank sldkfjsdl

unsigned char mask[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
#define tget(i) ( (t[(i)/8]&mask[(i)%8]) ? 1 : 0 )
#define tset(i, b) t[(i)/8]=(b) ? (mask[(i)%8]|t[(i)/8]) : ((~mask[(i)%8])&t[(i)/8])
#define chr(i) (cs==sizeof(int)?((int*)s)[i]:((unsigned char *)s)[i])
#define isLMS(i) (i>0 && tget(i) && !tget(i-1))

// find the start or end of each bucket
void getBuckets(unsigned char *s, int *bkt, int n, int K, int cs, bool end) {
    int i, sum = 0;
    for (i = 0; i <= K; i++)
        bkt[i] = 0; // clear all buckets
    for (i = 0; i < n; i++)
        bkt[chr(i)]++; // compute the size of each bucket
    for (i = 0; i <= K; i++) {
        sum += bkt[i];
        bkt[i] = end ? sum : sum - bkt[i];
    }
}
// compute SAl
void induceSAl(unsigned char *t, int *SA, unsigned char *s, int *bkt, int n, int K, int cs, bool end) {
    int i, j;
    getBuckets(s, bkt, n, K, cs, end); // find starts of buckets
    for (i = 0; i < n; i++) {
        j = SA[i] - 1;
        if (j >= 0 && !tget(j))
            SA[bkt[chr(j)]++] = j;
    }
}
// compute SAs
void induceSAs(unsigned char *t, int *SA, unsigned char *s, int *bkt, int n, int K, int cs, bool end) {
    int i, j;
    getBuckets(s, bkt, n, K, cs, end); // find ends of buckets
    for (i = n - 1; i >= 0; i--) {
        j = SA[i] - 1;
        if (j >= 0 && tget(j))
            SA[--bkt[chr(j)]] = j;
    }
}

// find the suffix array SA of s[0..n-1] in {1..K}^n
// require s[n-1]=0 (the sentinel!), n>=2
// use a working space (excluding s and SA) of at most 2.25n+O(1) for a constant alphabet
void SA_IS(unsigned char *s, int *SA, int n, int K, int cs) {
    int i, j;
    unsigned char *t = (unsigned char *) malloc(n / 8 + 1); // LS-type array in bits
    // Classify the type of each character
    tset(n-2, 0);
    tset(n-1, 1); // the sentinel must be in s1, important!!!
    for (i = n - 3; i >= 0; i--)
        tset(i, (chr(i)<chr(i+1) || (chr(i)==chr(i+1) && tget(i+1)==1))?1:0);
    // stage 1: reduce the problem by at least 1/2
    // sort all the S-substrings
    int *bkt = (int *) malloc(sizeof(int) * (K + 1)); // bucket array
    getBuckets(s, bkt, n, K, cs, true); // find ends of buckets
    for (i = 0; i < n; i++)
        SA[i] = -1;
    for (i = 1; i < n; i++)
        if (isLMS(i))
            SA[--bkt[chr(i)]] = i;
    induceSAl(t, SA, s, bkt, n, K, cs, false);
    induceSAs(t, SA, s, bkt, n, K, cs, true);
    free(bkt);
    // compact all the sorted substrings into the first n1 items of SA
    // 2*n1 must be not larger than n (proveable)
    int n1 = 0;
    for (i = 0; i < n; i++)
        if (isLMS(SA[i]))
            SA[n1++] = SA[i];
    // find the lexicographic names of all substrings
    for (i = n1; i < n; i++)
        SA[i] = -1; // init the name array buffer
    int name = 0, prev = -1;
    for (i = 0; i < n1; i++) {
        int pos = SA[i];
        bool diff = false;
        for (int d = 0; d < n; d++)
            if (prev == -1 || chr(pos+d) != chr(prev+d) || tget(pos+d) != tget(prev+d)) {
                diff = true;
                break;
            } else if (d > 0 && (isLMS(pos+d) || isLMS(prev+d)))
                break;
        if (diff) {
            name++;
            prev = pos;
        }
        pos = (pos % 2 == 0) ? pos / 2 : (pos - 1) / 2;
        SA[n1 + pos] = name - 1;
    }
    for (i = n - 1, j = n - 1; i >= n1; i--)
        if (SA[i] >= 0)
            SA[j--] = SA[i];
    // stage 2: solve the reduced problem
    // recurse if names are not yet unique
    int *SA1 = SA, *s1 = SA + n - n1;
    if (name < n1)
        SA_IS((unsigned char*) s1, SA1, n1, name - 1, sizeof(int));
    else
        // generate the suffix array of s1 directly
        for (i = 0; i < n1; i++)
            SA1[s1[i]] = i;
    // stage 3: induce the result for the original problem
    bkt = (int *) malloc(sizeof(int) * (K + 1)); // bucket array
    // put all left-most S characters into their buckets
    getBuckets(s, bkt, n, K, cs, true); // find ends of buckets
    for (i = 1, j = 0; i < n; i++)
        if (isLMS(i))
            s1[j++] = i; // get p1
    for (i = 0; i < n1; i++)
        SA1[i] = s1[SA1[i]]; // get index in s
    for (i = n1; i < n; i++)
        SA[i] = -1; // init SA[n1..n-1]
    for (i = n1 - 1; i >= 0; i--) {
        j = SA[i];
        SA[i] = -1;
        SA[--bkt[chr(j)]] = j;
    }
    induceSAl(t, SA, s, bkt, n, K, cs, false);
    induceSAs(t, SA, s, bkt, n, K, cs, true);
    free(bkt);
    free(t);
}

int sa[maxn];
int rank[maxn];
unsigned char *q;
int n;
int p[maxn], col[maxn], p2[maxn], num[maxn];
int left[maxn];
int right[maxn];
int l = 0;
int lcp[maxn], lcp1[maxn];
int pos[maxn];
int color[maxn];
string s,t;

bool cmp(int i, int j)
{
	for (int k = 0; k < l; k++)
	{
		if (s[(i + k) % l] < s[(j + k) % l])
			return true;
		if (s[(i + k) % l] > s[(j + k) % l])
			return false;
	}
	return true;
}

int main()
{
	ios_base :: sync_with_stdio(false);
	cin >> s;
	cin >> t;
	int n = s.size();
	s = s + "#" + t + "!";
    l = s.size();
    q = (unsigned char*) s.c_str();
    SA_IS(q, p, l + 1, 256, 1);
    for (int i = 0; i < l; i++)
    	p[i] = p[i + 1];
//    for (int i = 0; i < l; i++)
  //  	cerr << p[i] << " ";
    //cerr << endl;

	// kasai li park
	for (int i = 0; i < l; i++)
		pos[p[i]] = i;
	int tmp = 0;
	for (int i = 0; i < l; i++)
	{
		if (tmp > 0)
		{
			tmp--;
		}
		if (pos[i] == l - 1)
		{
			lcp[l - 1] = 0;
			tmp = 0;
		} else 
		{
			int j = p[pos[i] + 1];
			while (max(i + tmp, j + tmp) < l && s[i + tmp] == s[j + tmp])
				tmp++;
			lcp[pos[i]] = tmp;
		}
	}	

	for (int i = 1; i < l; i++)
	{
		color[i] = ((p[i] < n) ? 0 : 1);
	}
	for (int i = 0; i < l; i++)
		left[i] = right[i] = inf;
	int cur = inf;
	int lst = cur;
	for (int i = 1; i < l; i++)
	{
		if (color[i] == 0)
		{
			if (cur < 0)
				left[i] = lst;
			else
				left[i] = cur;
			cur = inf;
			lst = min(lst, lcp[i]);
		} else
		{
			cur = lcp[i];
			lst = cur;
		}		
	}
	cur = inf;
	lst = cur;
	for (int i = l - 1; i >= 1; i--)
	{
		if (color[i] == 0)
		{
			if (cur < 0)
				right[i] = lst;
			else
				right[i] = cur;
			cur = inf;
			lst = min(lst, lcp[i - 1]);
		} else 
		{
			cur = lcp[i - 1];
			lst = cur;
		}
	}
	int maxAns = -1e9;
	int L = 0;
	int R = 0;
	for (int i = 1; i < l; i++)
		if (color[i] == 0)
		{
			if (left[i] > 0)
			{
				int pos = p[i];
				if (maxAns < left[i] - max(pos, n - (pos + left[i])))
				{
					maxAns = left[i] - max(pos, n - (pos + left[i]));
					L = pos;
					R = pos + left[i] - 1;
				}
				if (maxAns == left[i] - max(pos, n - (pos + left[i])) && L > pos)
				{
					maxAns = left[i] - max(pos, n - (pos + left[i]));
					L = pos;
					R = pos + left[i] - 1;
				}
			}
			if (right[i] > 0)
			{
				int pos = p[i];
				if (maxAns < right[i] - max(pos, n - (pos + right[i])))
				{
					maxAns = right[i] - max(pos, n - (pos + right[i]));
					L = pos;
					R = pos + right[i] - 1;
				}
				if (maxAns == right[i] - max(pos, n - (pos + right[i])) && L > pos)
				{
					maxAns = right[i] - max(pos, n - (pos + right[i]));
					L = pos;
					R = pos + right[i] - 1;
				}

			}
		}
	if (maxAns == -1e9)
		cout << "-1 -1";
		else
			cout << L << " " << R  << endl;
	return 0;		
}