#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(const pair<A, B> &p);
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p);
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<class A, class T = typename A::value_type> string to_string(const A &v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) {
	return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
	cerr << " " << to_string(h);
	debug_out(t...);
}
#ifndef ONLINE_JUDGE
	#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
	#define debug(...) if (0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

/**
 * Author: Yuhao Yao
 * Date: 23-05-01
 * Description: Hash struct. $1000000007$ and $1000050131$ are good moduli.
 * Status: tested on https://ac.nowcoder.com/acm/contest/33192/I, https://ac.nowcoder.com/acm/contest/33193/I.
 */
template<int m1, int m2>
struct Hash {
	int x, y;
	Hash(ll a, ll b): x(a % m1), y(b % m2) {
		if (x < 0) x += m1;
		if (y < 0) y += m2;
	}
	Hash(ll a = 0): Hash(a, a) {}

	using H = Hash;
	static int norm(int x, int mod) { return x >= mod ? x - mod : x < 0 ? x + mod : x; }
	H& operator +=(H b) { x = norm(x + b.x, m1); y = norm(y + b.y, m2); return *this; }
	H& operator -=(H b) { x = norm(x - b.x, m1); y = norm(y - b.y, m2); return *this; }
	H& operator *=(H b) { x = 1ll * x * b.x % m1; y = 1ll * y * b.y % m2; return *this; }
	friend H operator +(H a, H b) { return a += b; }
	friend H operator -(H a, H b) { return a -= b; }
	friend H operator *(H a, H b) { return a *= b; }
	
	friend bool operator ==(H a, H b) { return tie(a.x, a.y) == tie(b.x, b.y); }
	friend bool operator !=(H a, H b) { return tie(a.x, a.y) != tie(b.x, b.y); }
	friend bool operator <(H a, H b) { return tie(a.x, a.y) < tie(b.x, b.y); }

	friend string to_string(H a) { return to_string(make_pair(a.x, a.y)); }
};
using hashv = Hash<1000000007, 1000050131>;

/**
 * Author: Yuhao Yao
 * Date: 22-10-24
 * Description: Hash of a string.
 * Usage: StringHash<unsigned long long> ha(s); // $s$ can be string or vector<int>.
 * Time: O(|s|).
 * Status: tested on https://qoj.ac/contest/144/problem/3009.
 */
template<class hashv> 
struct StringHash {
	const hashv base = 131; // change this if you hash a vector<int>.
	int n;
	vector<hashv> hs, pw;

	template<class T>
	StringHash(const T &s): n(sz(s)), hs(n + 1), pw(n + 1) {
		pw[0] = 1;
		rep(i, 1, n) pw[i] = pw[i - 1] * base;
		rep(i, 0, n - 1) hs[i + 1] = hs[i] * base + s[i];
	}

	hashv get(int l, int r) { return hs[r + 1] - hs[l] * pw[r + 1 - l]; }
	int lcp(int x, int y) {
		int lo = 0, hi = n - max(x, y) + 1;
		while (lo < hi) {
			int mid = (lo + hi) >> 1;
			if (get(x, x + mid - 1) != get(y, y + mid - 1)) hi = mid;
			else lo = mid + 1;
		}
		return hi - 1;
	}
};



/**
 * Author: Yuhao Yao
 * Source: Adapted from https://qoj.ac/submission/27364.
 * Date: 22-10-24
 * Description: Manacher Algorithm for finding all palindrome subtrings of $s = s_0...s_{n - 1}$. $s$ can actually be string or vector (say vector<int>).
 *  For returned vector $len$, $len[i * 2] = r$ means that $s_{i - r + 1}...s_{i + r - 1}$ is the maximal palindrome centered at position $i$.
 *  $len[i * 2 + 1] = r$ means that $s_{i - r + 1}...s_{i + r}$ is the maximal palindrome centered between position $i$ and $i + 1$.
 * Usage: vi rs = Manacher(s); // $s$ can be string or vector.
 * Time: O(|s|).
 * Status: tested on https://www.luogu.com.cn/problem/P3805, https://qoj.ac/problem/4844, https://www.luogu.com.cn/problem/P6216, https://www.luogu.com.cn/problem/P4555.
 */

template<class T>
vi Manacher(const T &s) {
	int n = sz(s), j = 0;
	vi len(n * 2 - 1, 1);
	rep(i, 1, n * 2 - 2) {
		int p = i / 2, q = i - p, r = (j + 1) / 2 + len[j] - 1;
		len[i] = r < q ? 0 : min(r - q + 1, len[j * 2 - i]);
		while (p > len[i] - 1 && q + len[i] < n && s[p - len[i]] == s[q + len[i]]) len[i]++;
		if (q + len[i] - 1 > r) j = i;
	}
	return len;
}

void InfoApply(set<int> &a, int l, int r, int x) {
	a.insert(x);
}

/**
 * Author: Yuhao Yao
 * Date: 23-04-01
 * Description: Segment tree with lazy propogation.
 * Usage: Always define functions \textbf{InfoApply} and \textbf{TagApply} to tell segment tree how you apply modification.
 *  Combine is set as plus so if you just let T be numerical type then you have range sum in the info and as range query result. To have something different, say rangeMin, define a struct with constructer and + operation.
 * Time: O(\log N) per operation.
 * Status: tested on https://codeforces.com/gym/103371/problem/M.
 */
template<class Info> class LazySegTree {
	#define ls i * 2
	#define rs i * 2 + 1

	int n;
	vector<Info> info;
public:
	LazySegTree(int n): n(n) {
		assert(n > 0);
		info.resize(4 << __lg(n));
	}
private:
	template<class... T>
	void apply(int i, int l, int r, const T&... val) {
		InfoApply(info[i], l, r, val...);
	}
public:
	template<class... T>
	void rangeApply(int ql, int qr, const T&... val) {
		auto dfs = [&](auto &dfs, int i, int l, int r) {
			if (qr < l || r < ql) return;
			if (ql <= l && r <= qr) {
				apply(i, l, r, val...);
				return;
			}
			int mid = (l + r) >> 1;
			dfs(dfs, ls, l, mid);
			dfs(dfs, rs, mid + 1, r);
		};
		dfs(dfs, 1, 0, n - 1);
	}

	void pointAsk(int p, function<void(Info&)> ask) {
		Info res{};
		auto dfs = [&](auto &dfs, int i, int l, int r) {
			if (p < l || r < p) return;
			ask(info[i]);
			if (p <= l && r <= p) {
				return;
			}
			int mid = (l + r) >> 1;
			dfs(dfs, ls, l, mid);
			dfs(dfs, rs, mid + 1, r);
		};
		dfs(dfs, 1, 0, n - 1);
	}

	#undef ls
	#undef rs
};

struct Solver {
	string s;
	int n;
	vector<int> rads;
	StringHash<hashv> sh;
	LazySegTree<set<int>> seg;
	
	string GetStr(const string &s) {
		string t = s;
		reverse(all(t));
		t = s + t;
		return t;
	}
	Solver(string &_s) : s(_s), n(sz(_s)), rads(Manacher(s)), sh(GetStr(s)), seg(sz(s)) {
		rep(i, 0, sz(rads) - 1) {
			int rad = rads[i];
			int l = i / 2 - rad + 1;
			int r = i / 2;
			seg.rangeApply(l, r, i);
		}
	}
	pii solve(int l, int r) {
		int x = sh.lcp(l, n * 2 - 1 - r);
		if (x >= r - l + 1) return pii{0, 0};
		else {
			int st = l + x;
			int ed = r - x;
			int thr = st + ed;
			int res = st;
			auto ask = [&](set<int> &S) {
				auto it = S.upper_bound(thr);
				if (it != S.begin()) {
					int x = *std::prev(it);
					chmax(res, x);
				}
			};
			seg.pointAsk(st, ask);
			int ned = res - st;

			int ans = r - l + 1 - x * 2 - (ned - st + 1);
			int ways = min(sh.lcp(ned + 1, ed + 1), x) + 1;
			return pii{ans, ways};
		}
	}
};

int main() {
	ios::sync_with_stdio(0); cin.tie(0);

	int n; cin >> n;
	string s; cin >> s;
	string t = s;
	reverse(all(t));

	Solver s1(s);
	Solver s2(t);

	int q; cin >> q; while (q--) {
		int l, r; cin >> l >> r;
		l--, r--;
		auto res1 = s1.solve(l, r);
		auto res2 = s2.solve(n - 1 - r, n - 1 - l);
		pii res;
		if (res1.first == res2.first) {
			res = {res1.first, res1.second + res2.second};
		} else {
			res = min(res1, res2);
		}
		printf("%d %d\n", res.first, res.second);
	}

	return 0;
}