// #pragma comment(linker, "/stack:200000000")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #pragma GCC optimize("unroll-loops")

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#ifdef on_linux
#include <sys/resource.h>
#endif

using namespace std;
using namespace __gnu_pbds;

#define sz(x)                   (int)((x).size())
#define all(x)                  (x).begin(), (x).end()
#define mem0(x)                 memset(x, 0, sizeof (x))
#define mem1(x)                 memset(x, -1, sizeof (x))
#define sleep(x)                std::this_thread::sleep_for(std::chrono::milliseconds(x))
#define DECIMAL(n)              std::cout << std::fixed << std::setprecision(n);
#define rep(i,a,b)              for(int32_t i = (a); i < (b); ++i)
#define between(i,x,y)          ((i) >= (x) && (i) <= (y))
// #define clamp(i,x,y)         clamp(i, x, y)
#define sqr(a)                  ((a) * (a))
#define pii                     pair<int32_t, int32_t>
#define pll                     pair<long long, long long>
#define mp                      make_pair
#define fi                      first
#define sc                      second
#define pb                      push_back
#define ppb                     pop_back
#define pf                      push_front
#define ppf                     pop_front
#define lbd                     lower_bound
#define ubd                     upper_bound
#define int                     long long
#define ll                      long long

template<typename T, typename U> istream& operator>>(istream& in, pair<T, U> &a) {in >> a.first >> a.second; return in;}
template<typename T, typename U> ostream& operator<<(ostream& out, pair<T, U> a) {out << "{" << a.first << ", " << a.second << "}"; return out;}
template<typename T, typename U> static inline void remin(T &x, U y) {if (y < x) {x = y;}}
template<typename T, typename U> static inline void remax(T &x, U y) {if (x < y) {x = y;}}

static mt19937_64 gen(chrono::duration_cast<chrono::nanoseconds>(chrono::high_resolution_clock::now().time_since_epoch()).count());

inline long long toint(const string &s) {stringstream ss; ss << s; long long x; ss >> x; return x;}
inline string tostring(long long number) {stringstream ss; ss << number; return ss.str();}
inline string tobin(long long x) {return bitset<63>(x).to_string();}

void alllower(string &u) {transform(u.begin(), u.end(), u.begin(), ::tolower); return;}
void allupper(string &u) {transform(u.begin(), u.end(), u.begin(), ::toupper); return;}

template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;
// erase, insert same as normal set

const long double PI = 3.14159265358979323846264338;
const long double eps = 1e-12;
const long long fftmod = 998244353;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const int32_t N = 1e5 + 10;
const int32_t NN = 1e6 + 10;



inline void dobbysolver(int testcase)
{
	string s;
	cin >> s;
	int n = sz(s);
	int ctr[26] = {};
	for (int i = 0; i < sz(s) - 1; ++i)
	{
		if (s[i] == s[i + 1])
		{
			cout << i + 1 << ' ' << i + 2;
			return;
		}
		else if (i != n - 2 && s[i] == s[i + 2])
		{
			cout << i + 1 << ' ' << i + 3;
			return;
		}
	}

	cout << -1 << ' ' << -1;

	return;
}

int32_t main()
{
#ifdef on_linux
	rlimit cpu_time {.rlim_cur = 2, .rlim_max = RLIM_INFINITY};
	setrlimit(RLIMIT_CPU, &cpu_time);
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	int TESTS = 1;
	//cin >> TESTS;
	for (int i = 1; i <= TESTS; ++i) {
		// cout << "Case #" << i << ": ";
		dobbysolver(i);
		if (i != TESTS)	cout << '\n';
	}
	return 0;
}

Measured memory_bytes: 512